recker 1.0.26 → 1.0.27

package/dist/browser/plugins/compression.js

@@ -0,0 +1,130 @@
+import { gzip, deflate, brotliCompress } from 'node:zlib';
+import { promisify } from 'node:util';
+import { UnsupportedError } from '../core/errors.js';
+const gzipAsync = promisify(gzip);
+const deflateAsync = promisify(deflate);
+const brotliAsync = promisify(brotliCompress);
+function isCompressible(contentType) {
+    if (!contentType)
+        return true;
+    const compressibleTypes = [
+        'text/',
+        'application/json',
+        'application/xml',
+        'application/javascript',
+        'application/x-www-form-urlencoded'
+    ];
+    return compressibleTypes.some(type => contentType.includes(type));
+}
+function getBodySize(body) {
+    if (!body)
+        return 0;
+    if (typeof body === 'string') {
+        return Buffer.byteLength(body, 'utf8');
+    }
+    if (body instanceof Buffer) {
+        return body.length;
+    }
+    if (body instanceof ArrayBuffer) {
+        return body.byteLength;
+    }
+    if (body instanceof Blob) {
+        return body.size;
+    }
+    if (typeof body === 'object') {
+        try {
+            return Buffer.byteLength(JSON.stringify(body), 'utf8');
+        }
+        catch {
+            return 0;
+        }
+    }
+    return 0;
+}
+function toBuffer(body) {
+    if (!body)
+        return null;
+    if (Buffer.isBuffer(body)) {
+        return body;
+    }
+    if (typeof body === 'string') {
+        return Buffer.from(body, 'utf8');
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(body);
+    }
+    if (typeof body === 'object') {
+        try {
+            return Buffer.from(JSON.stringify(body), 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+async function compress(data, algorithm) {
+    switch (algorithm) {
+        case 'gzip':
+            return await gzipAsync(data);
+        case 'deflate':
+            return await deflateAsync(data);
+        case 'br':
+            return await brotliAsync(data);
+        default:
+            throw new UnsupportedError(`Unsupported compression algorithm: ${algorithm}`, {
+                feature: algorithm,
+            });
+    }
+}
+export function compression(options = {}) {
+    const { algorithm = 'gzip', threshold = 1024, force = false, methods = ['POST', 'PUT', 'PATCH'] } = options;
+    return async (req, next) => {
+        const shouldCompress = methods.includes(req.method);
+        if (!shouldCompress || !req.body) {
+            return next(req);
+        }
+        if (req.headers.has('Content-Encoding')) {
+            return next(req);
+        }
+        const contentType = req.headers.get('Content-Type');
+        if (!isCompressible(contentType)) {
+            return next(req);
+        }
+        const bodySize = getBodySize(req.body);
+        if (!force && bodySize < threshold) {
+            return next(req);
+        }
+        const buffer = toBuffer(req.body);
+        if (!buffer) {
+            return next(req);
+        }
+        try {
+            const compressed = await compress(buffer, algorithm);
+            if (!force && compressed.length >= buffer.length) {
+                return next(req);
+            }
+            const newHeaders = new Headers(req.headers);
+            newHeaders.set('Content-Encoding', algorithm);
+            newHeaders.set('Content-Length', compressed.length.toString());
+            const compressedReq = {
+                ...req,
+                body: compressed,
+                headers: newHeaders
+            };
+            return next(compressedReq);
+        }
+        catch {
+            return next(req);
+        }
+    };
+}
+export function createCompressionMiddleware(config) {
+    if (!config) {
+        return null;
+    }
+    if (config === true) {
+        return compression();
+    }
+    return compression(config);
+}

package/dist/browser/plugins/cookie-jar.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '../types/index.js';
+export interface CookieJarOptions {
+    store?: Map<string, string>;
+}
+export declare function cookieJarPlugin(options?: CookieJarOptions): Plugin;

package/dist/browser/plugins/cookie-jar.js

@@ -0,0 +1,72 @@
+export function cookieJarPlugin(options = {}) {
+    const store = new Map();
+    if (options.store) {
+        if (options.store instanceof Map) {
+            store.set('*', options.store);
+        }
+    }
+    return (client) => {
+        client.beforeRequest((req) => {
+            const url = new URL(req.url);
+            const hostname = url.hostname;
+            const cookieList = [];
+            const addCookies = (domainStore) => {
+                if (domainStore) {
+                    domainStore.forEach((value, key) => {
+                        cookieList.push(`${key}=${value}`);
+                    });
+                }
+            };
+            addCookies(store.get(hostname));
+            for (const [domain, domainStore] of store.entries()) {
+                if (domain !== '*' && domain !== hostname && hostname.endsWith(domain)) {
+                    addCookies(domainStore);
+                }
+                if (domain === '*') {
+                    addCookies(domainStore);
+                }
+            }
+            if (cookieList.length > 0) {
+                const existing = req.headers.get('cookie');
+                const newCookies = cookieList.join('; ');
+                req.headers.set('cookie', existing ? `${existing}; ${newCookies}` : newCookies);
+            }
+        });
+        client.afterResponse((req, res) => {
+            const setCookie = res.headers.get('set-cookie');
+            if (!setCookie)
+                return;
+            const url = new URL(req.url);
+            let domain = url.hostname;
+            const cookies = splitCookies(setCookie);
+            cookies.forEach(cookieStr => {
+                const parts = cookieStr.split(';');
+                const [nameValue] = parts;
+                if (!nameValue)
+                    return;
+                const [key, ...valParts] = nameValue.split('=');
+                if (!key)
+                    return;
+                const value = valParts.join('=').trim();
+                let specificDomain = domain;
+                const domainPart = parts.find(p => p.trim().toLowerCase().startsWith('domain='));
+                if (domainPart) {
+                    const d = domainPart.split('=')[1]?.trim();
+                    if (d)
+                        specificDomain = d;
+                }
+                if (!store.has(specificDomain)) {
+                    store.set(specificDomain, new Map());
+                }
+                const domainStore = store.get(specificDomain);
+                domainStore.set(key.trim(), value);
+                if (options.store) {
+                    options.store.set(key.trim(), value);
+                }
+            });
+        });
+    };
+}
+function splitCookies(header) {
+    return header.split(/,(?=\s*[a-zA-Z0-9_]+=[^;])/g);
+}

package/dist/browser/plugins/dedup.d.ts

@@ -0,0 +1,5 @@
+import { Plugin, ReckerRequest } from '../types/index.js';
+export interface DedupOptions {
+    keyGenerator?: (req: ReckerRequest) => string;
+}
+export declare function dedupPlugin(options?: DedupOptions): Plugin;

package/dist/browser/plugins/dedup.js

@@ -0,0 +1,35 @@
+const keyBuffer = { method: '', url: '' };
+export function dedupPlugin(options = {}) {
+    const pendingRequests = new Map();
+    const generateKey = options.keyGenerator || ((req) => {
+        return req.method + ':' + req.url;
+    });
+    const dedupMiddleware = async (req, next) => {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            return next(req);
+        }
+        const key = generateKey(req);
+        if (pendingRequests.has(key)) {
+            const response = await pendingRequests.get(key);
+            return response.clone();
+        }
+        const promise = next(req)
+            .then((res) => {
+            return res;
+        })
+            .finally(() => {
+            pendingRequests.delete(key);
+        });
+        pendingRequests.set(key, promise);
+        try {
+            const response = await promise;
+            return response.clone ? response.clone() : response;
+        }
+        catch (err) {
+            throw err;
+        }
+    };
+    return (client) => {
+        client.use(dedupMiddleware);
+    };
+}

package/dist/browser/plugins/graphql.d.ts

@@ -0,0 +1,13 @@
+import { Plugin, ReckerRequest, ReckerResponse } from '../types/index.js';
+import { Client } from '../core/client.js';
+import { ReckerError } from '../core/errors.js';
+export declare class GraphQLError extends ReckerError {
+    errors: any[];
+    response: ReckerResponse;
+    constructor(errors: any[], response: ReckerResponse, request?: ReckerRequest);
+}
+export interface GraphQLOptions {
+    throwOnErrors?: boolean;
+}
+export declare function graphqlPlugin(options?: GraphQLOptions): Plugin;
+export declare function graphql<T = any>(client: Client, query: string, variables?: Record<string, any>, options?: any): Promise<T>;

package/dist/browser/plugins/graphql.js

@@ -0,0 +1,58 @@
+import { ReckerError } from '../core/errors.js';
+export class GraphQLError extends ReckerError {
+    errors;
+    response;
+    constructor(errors, response, request) {
+        const message = errors?.[0]?.message || 'GraphQL response contains errors';
+        const suggestions = [
+            'Check the GraphQL query and variables for schema compliance.',
+            'Inspect the GraphQL errors array for details.',
+            'Fix validation errors before retrying; network errors may be retriable.'
+        ];
+        super(message, request, response, suggestions, false);
+        this.errors = errors;
+        this.response = response;
+        this.name = 'GraphQLError';
+    }
+}
+export function graphqlPlugin(options = {}) {
+    const throwOnErrors = options.throwOnErrors !== false;
+    const middleware = async (req, next) => {
+        const res = await next(req);
+        const contentType = res.headers.get('content-type');
+        if (throwOnErrors && contentType && contentType.includes('application/json')) {
+            const clone = res.clone();
+            try {
+                const body = await clone.json();
+                if (body && Array.isArray(body.errors) && body.errors.length > 0) {
+                    throw new GraphQLError(body.errors, res);
+                }
+            }
+            catch (err) {
+                if (err instanceof GraphQLError)
+                    throw err;
+            }
+        }
+        return res;
+    };
+    return (client) => {
+        client.use(middleware);
+    };
+}
+export async function graphql(client, query, variables = {}, options = {}) {
+    const opMatch = query.match(/(query|mutation|subscription)\s+([a-zA-Z0-9_]+)/);
+    const operationName = opMatch ? opMatch[2] : undefined;
+    const payload = { query, variables, operationName };
+    if (options.method === 'GET') {
+        const params = {
+            query,
+            variables: JSON.stringify(variables),
+            ...(operationName && { operationName })
+        };
+        options.params = { ...options.params, ...params };
+        const res = await client.get('', options).json();
+        return res.data;
+    }
+    const res = await client.post('', payload, options).json();
+    return res.data;
+}

package/dist/browser/plugins/grpc-web.d.ts

@@ -0,0 +1,79 @@
+import type { Client } from '../core/client.js';
+export interface GrpcWebOptions {
+    baseUrl: string;
+    metadata?: Record<string, string>;
+    timeout?: number;
+    textFormat?: boolean;
+}
+export interface GrpcMetadata {
+    [key: string]: string;
+}
+export interface GrpcCallOptions {
+    metadata?: GrpcMetadata;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+export interface GrpcStatus {
+    code: number;
+    message: string;
+    details?: unknown;
+}
+export interface GrpcResponse<T> {
+    message: T;
+    metadata: GrpcMetadata;
+    status: GrpcStatus;
+}
+export interface UnaryCall<TRequest, TResponse> {
+    (request: TRequest, options?: GrpcCallOptions): Promise<GrpcResponse<TResponse>>;
+}
+export interface ServerStreamCall<TRequest, TResponse> {
+    (request: TRequest, options?: GrpcCallOptions): AsyncGenerator<TResponse, void, unknown>;
+}
+export declare const GrpcStatusCode: {
+    readonly OK: 0;
+    readonly CANCELLED: 1;
+    readonly UNKNOWN: 2;
+    readonly INVALID_ARGUMENT: 3;
+    readonly DEADLINE_EXCEEDED: 4;
+    readonly NOT_FOUND: 5;
+    readonly ALREADY_EXISTS: 6;
+    readonly PERMISSION_DENIED: 7;
+    readonly RESOURCE_EXHAUSTED: 8;
+    readonly FAILED_PRECONDITION: 9;
+    readonly ABORTED: 10;
+    readonly OUT_OF_RANGE: 11;
+    readonly UNIMPLEMENTED: 12;
+    readonly INTERNAL: 13;
+    readonly UNAVAILABLE: 14;
+    readonly DATA_LOSS: 15;
+    readonly UNAUTHENTICATED: 16;
+};
+export type GrpcStatusCodeType = typeof GrpcStatusCode[keyof typeof GrpcStatusCode];
+export declare class GrpcError extends Error {
+    readonly code: GrpcStatusCodeType;
+    readonly metadata: GrpcMetadata;
+    readonly details?: unknown;
+    constructor(status: GrpcStatus, metadata?: GrpcMetadata);
+    static fromCode(code: GrpcStatusCodeType, message: string): GrpcError;
+}
+export interface MessageCodec<T> {
+    encode(message: T): Uint8Array;
+    decode(data: Uint8Array): T;
+}
+export declare function jsonCodec<T>(): MessageCodec<T>;
+export declare class GrpcWebClient {
+    private client;
+    private options;
+    constructor(client: Client, options: GrpcWebOptions);
+    unary<TRequest, TResponse>(service: string, method: string, request: TRequest, codec: MessageCodec<TRequest> & MessageCodec<TResponse>, options?: GrpcCallOptions): Promise<GrpcResponse<TResponse>>;
+    serverStream<TRequest, TResponse>(service: string, method: string, request: TRequest, codec: MessageCodec<TRequest> & MessageCodec<TResponse>, options?: GrpcCallOptions): AsyncGenerator<TResponse, void, unknown>;
+    service<T extends Record<string, unknown>>(serviceName: string, methods: T): T;
+    private parseUnaryResponse;
+}
+export declare function createGrpcWebClient(client: Client, options: GrpcWebOptions): GrpcWebClient;
+export declare function grpcWeb(): (client: Client) => void;
+declare module '../core/client.js' {
+    interface Client {
+        grpcWeb(options?: Partial<GrpcWebOptions>): GrpcWebClient;
+    }
+}

package/dist/browser/plugins/grpc-web.js

@@ -0,0 +1,261 @@
+export const GrpcStatusCode = {
+    OK: 0,
+    CANCELLED: 1,
+    UNKNOWN: 2,
+    INVALID_ARGUMENT: 3,
+    DEADLINE_EXCEEDED: 4,
+    NOT_FOUND: 5,
+    ALREADY_EXISTS: 6,
+    PERMISSION_DENIED: 7,
+    RESOURCE_EXHAUSTED: 8,
+    FAILED_PRECONDITION: 9,
+    ABORTED: 10,
+    OUT_OF_RANGE: 11,
+    UNIMPLEMENTED: 12,
+    INTERNAL: 13,
+    UNAVAILABLE: 14,
+    DATA_LOSS: 15,
+    UNAUTHENTICATED: 16,
+};
+export class GrpcError extends Error {
+    code;
+    metadata;
+    details;
+    constructor(status, metadata = {}) {
+        super(status.message);
+        this.name = 'GrpcError';
+        this.code = status.code;
+        this.metadata = metadata;
+        this.details = status.details;
+    }
+    static fromCode(code, message) {
+        return new GrpcError({ code, message }, {});
+    }
+}
+export function jsonCodec() {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        encode(message) {
+            return encoder.encode(JSON.stringify(message));
+        },
+        decode(data) {
+            return JSON.parse(decoder.decode(data));
+        },
+    };
+}
+function encodeGrpcFrame(data, isTrailers = false) {
+    const frame = new Uint8Array(5 + data.length);
+    frame[0] = isTrailers ? 128 : 0;
+    const view = new DataView(frame.buffer);
+    view.setUint32(1, data.length, false);
+    frame.set(data, 5);
+    return frame;
+}
+function decodeGrpcFrames(data) {
+    const frames = [];
+    let offset = 0;
+    while (offset < data.length) {
+        if (offset + 5 > data.length)
+            break;
+        const flags = data[offset];
+        const isTrailers = (flags & 128) !== 0;
+        const view = new DataView(data.buffer, data.byteOffset + offset + 1, 4);
+        const length = view.getUint32(0, false);
+        if (offset + 5 + length > data.length)
+            break;
+        const payload = data.slice(offset + 5, offset + 5 + length);
+        frames.push({ isTrailers, payload });
+        offset += 5 + length;
+    }
+    return frames;
+}
+function parseTrailers(data) {
+    const decoder = new TextDecoder();
+    const text = decoder.decode(data);
+    const metadata = {};
+    for (const line of text.split('\r\n')) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.slice(0, colonIndex).trim().toLowerCase();
+            const value = line.slice(colonIndex + 1).trim();
+            metadata[key] = value;
+        }
+    }
+    return metadata;
+}
+export class GrpcWebClient {
+    client;
+    options;
+    constructor(client, options) {
+        this.client = client;
+        this.options = {
+            baseUrl: options.baseUrl,
+            metadata: options.metadata ?? {},
+            timeout: options.timeout ?? 30000,
+            textFormat: options.textFormat ?? true,
+        };
+    }
+    async unary(service, method, request, codec, options) {
+        const url = `${this.options.baseUrl}/${service}/${method}`;
+        const encoded = codec.encode(request);
+        const frame = encodeGrpcFrame(encoded);
+        const contentType = this.options.textFormat
+            ? 'application/grpc-web-text'
+            : 'application/grpc-web+proto';
+        const body = this.options.textFormat
+            ? btoa(String.fromCharCode(...frame))
+            : frame;
+        const headers = {
+            'Content-Type': contentType,
+            'Accept': contentType,
+            'X-Grpc-Web': '1',
+            ...this.options.metadata,
+            ...options?.metadata,
+        };
+        const requestOptions = {
+            headers,
+            timeout: options?.timeout ?? this.options.timeout,
+            signal: options?.signal,
+        };
+        const response = await this.client.post(url, body, requestOptions);
+        return this.parseUnaryResponse(response, codec);
+    }
+    async *serverStream(service, method, request, codec, options) {
+        const url = `${this.options.baseUrl}/${service}/${method}`;
+        const encoded = codec.encode(request);
+        const frame = encodeGrpcFrame(encoded);
+        const contentType = this.options.textFormat
+            ? 'application/grpc-web-text'
+            : 'application/grpc-web+proto';
+        const body = this.options.textFormat
+            ? btoa(String.fromCharCode(...frame))
+            : frame;
+        const headers = {
+            'Content-Type': contentType,
+            'Accept': contentType,
+            'X-Grpc-Web': '1',
+            ...this.options.metadata,
+            ...options?.metadata,
+        };
+        const response = await this.client.post(url, body, {
+            headers,
+            timeout: options?.timeout ?? this.options.timeout,
+            signal: options?.signal,
+        });
+        const stream = response.read();
+        if (!stream) {
+            throw new GrpcError({ code: GrpcStatusCode.INTERNAL, message: 'No response body' }, {});
+        }
+        const reader = stream.getReader();
+        let buffer = new Uint8Array(0);
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (value) {
+                    let chunk = value;
+                    if (this.options.textFormat) {
+                        const text = new TextDecoder().decode(value);
+                        const decoded = atob(text);
+                        chunk = new Uint8Array(decoded.length);
+                        for (let i = 0; i < decoded.length; i++) {
+                            chunk[i] = decoded.charCodeAt(i);
+                        }
+                    }
+                    const newBuffer = new Uint8Array(buffer.length + chunk.length);
+                    newBuffer.set(buffer);
+                    newBuffer.set(chunk, buffer.length);
+                    buffer = newBuffer;
+                    const frames = decodeGrpcFrames(buffer);
+                    let consumedBytes = 0;
+                    for (const frame of frames) {
+                        consumedBytes += 5 + frame.payload.length;
+                        if (frame.isTrailers) {
+                            const trailers = parseTrailers(frame.payload);
+                            const status = parseInt(trailers['grpc-status'] ?? '0', 10);
+                            const message = trailers['grpc-message'] ?? '';
+                            if (status !== GrpcStatusCode.OK) {
+                                throw new GrpcError({ code: status, message }, trailers);
+                            }
+                        }
+                        else {
+                            yield codec.decode(frame.payload);
+                        }
+                    }
+                    if (consumedBytes > 0) {
+                        buffer = buffer.slice(consumedBytes);
+                    }
+                }
+                if (done)
+                    break;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    service(serviceName, methods) {
+        const service = {};
+        for (const [methodName, _config] of Object.entries(methods)) {
+            service[methodName] = async (request, options) => {
+                const codec = jsonCodec();
+                return this.unary(serviceName, methodName, request, codec, options);
+            };
+        }
+        return service;
+    }
+    async parseUnaryResponse(response, codec) {
+        let data;
+        if (this.options.textFormat) {
+            const text = await response.text();
+            const decoded = atob(text);
+            data = new Uint8Array(decoded.length);
+            for (let i = 0; i < decoded.length; i++) {
+                data[i] = decoded.charCodeAt(i);
+            }
+        }
+        else {
+            const blob = await response.blob();
+            data = new Uint8Array(await blob.arrayBuffer());
+        }
+        const frames = decodeGrpcFrames(data);
+        let message;
+        let metadata = {};
+        let status = { code: GrpcStatusCode.OK, message: '' };
+        for (const frame of frames) {
+            if (frame.isTrailers) {
+                metadata = parseTrailers(frame.payload);
+                status = {
+                    code: parseInt(metadata['grpc-status'] ?? '0', 10),
+                    message: metadata['grpc-message'] ?? '',
+                };
+            }
+            else {
+                message = codec.decode(frame.payload);
+            }
+        }
+        const headerStatus = response.headers.get('grpc-status');
+        if (headerStatus) {
+            status.code = parseInt(headerStatus, 10);
+            status.message = response.headers.get('grpc-message') ?? '';
+        }
+        if (status.code !== GrpcStatusCode.OK) {
+            throw new GrpcError(status, metadata);
+        }
+        if (message === undefined) {
+            throw new GrpcError({ code: GrpcStatusCode.INTERNAL, message: 'No message in response' }, metadata);
+        }
+        return { message, metadata, status };
+    }
+}
+export function createGrpcWebClient(client, options) {
+    return new GrpcWebClient(client, options);
+}
+export function grpcWeb() {
+    return (client) => {
+        client.grpcWeb = (options) => {
+            const baseUrl = options?.baseUrl ?? client.config?.baseUrl ?? '';
+            return createGrpcWebClient(client, { baseUrl, ...options });
+        };
+    };
+}