recker 1.0.26 → 1.0.27

package/dist/browser/plugins/jsonrpc.js

@@ -0,0 +1,143 @@
+export const JsonRpcErrorCodes = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+    SERVER_ERROR: -32000,
+};
+export class JsonRpcException extends Error {
+    code;
+    data;
+    constructor(error) {
+        super(error.message);
+        this.name = 'JsonRpcException';
+        this.code = error.code;
+        this.data = error.data;
+    }
+    static isParseError(error) {
+        return error.code === JsonRpcErrorCodes.PARSE_ERROR;
+    }
+    static isInvalidRequest(error) {
+        return error.code === JsonRpcErrorCodes.INVALID_REQUEST;
+    }
+    static isMethodNotFound(error) {
+        return error.code === JsonRpcErrorCodes.METHOD_NOT_FOUND;
+    }
+    static isInvalidParams(error) {
+        return error.code === JsonRpcErrorCodes.INVALID_PARAMS;
+    }
+    static isInternalError(error) {
+        return error.code === JsonRpcErrorCodes.INTERNAL_ERROR;
+    }
+    static isServerError(error) {
+        return error.code >= -32099 && error.code <= -32000;
+    }
+}
+export class JsonRpcClient {
+    client;
+    options;
+    idCounter = 0;
+    constructor(client, options) {
+        this.client = client;
+        this.options = {
+            endpoint: options.endpoint,
+            requestOptions: options.requestOptions ?? {},
+            autoId: options.autoId ?? true,
+            idGenerator: options.idGenerator ?? (() => ++this.idCounter),
+            throwOnError: options.throwOnError ?? true,
+        };
+    }
+    async call(method, params, options) {
+        const id = this.options.autoId ? this.options.idGenerator() : null;
+        const request = {
+            jsonrpc: '2.0',
+            method,
+            id,
+        };
+        if (params !== undefined) {
+            request.params = params;
+        }
+        const response = await this.sendRequest(request, options);
+        if (response.error) {
+            if (this.options.throwOnError) {
+                throw new JsonRpcException(response.error);
+            }
+            return undefined;
+        }
+        return response.result;
+    }
+    async notify(method, params, options) {
+        const request = {
+            jsonrpc: '2.0',
+            method,
+        };
+        if (params !== undefined) {
+            request.params = params;
+        }
+        await this.client.post(this.options.endpoint, {
+            ...this.options.requestOptions,
+            ...options,
+            json: request,
+        });
+    }
+    async batch(requests, options) {
+        const batchRequests = requests.map((req, index) => ({
+            jsonrpc: '2.0',
+            method: req.method,
+            params: req.params,
+            id: req.id ?? (this.options.autoId ? this.options.idGenerator() : index),
+        }));
+        const response = await this.client.post(this.options.endpoint, {
+            ...this.options.requestOptions,
+            ...options,
+            json: batchRequests,
+        });
+        const responses = await response.json();
+        const errors = responses
+            .filter((r) => !!r.error)
+            .map((r) => r.error);
+        return {
+            responses,
+            errors,
+            hasErrors: errors.length > 0,
+        };
+    }
+    getFromBatch(batch, id) {
+        const response = batch.responses.find((r) => r.id === id);
+        if (response?.error && this.options.throwOnError) {
+            throw new JsonRpcException(response.error);
+        }
+        return response?.result;
+    }
+    proxy() {
+        return new Proxy({}, {
+            get: (_, method) => {
+                return (...args) => {
+                    if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && !Array.isArray(args[0])) {
+                        return this.call(method, args[0]);
+                    }
+                    return this.call(method, args);
+                };
+            },
+        });
+    }
+    async sendRequest(request, options) {
+        const response = await this.client.post(this.options.endpoint, {
+            ...this.options.requestOptions,
+            ...options,
+            json: request,
+        });
+        return response.json();
+    }
+}
+export function createJsonRpcClient(client, options) {
+    return new JsonRpcClient(client, options);
+}
+export function jsonrpc() {
+    return (client) => {
+        client.jsonrpc = (endpoint, options) => {
+            return createJsonRpcClient(client, { endpoint, ...options });
+        };
+    };
+}

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

@@ -0,0 +1,13 @@
+import { Plugin, ReckerRequest } from '../types/index.js';
+import { Logger } from '../types/logger.js';
+export interface LoggerPluginOptions {
+    logger?: Logger;
+    level?: 'debug' | 'info';
+    showHeaders?: boolean;
+    showBody?: boolean;
+    showTimings?: boolean;
+}
+export declare function loggerPlugin(options?: LoggerPluginOptions): Plugin;
+export declare function toCurl(req: ReckerRequest): string;
+export type { Logger } from '../types/logger.js';
+export { consoleLogger, silentLogger, createLevelLogger } from '../types/logger.js';

package/dist/browser/plugins/logger.js

@@ -0,0 +1,108 @@
+import { consoleLogger } from '../types/logger.js';
+export function loggerPlugin(options = {}) {
+    const log = options.logger || consoleLogger;
+    const level = options.level || 'info';
+    const showHeaders = options.showHeaders || false;
+    const showBody = options.showBody || false;
+    const showTimings = options.showTimings !== false;
+    const timers = new WeakMap();
+    const logFn = level === 'debug' ? log.debug.bind(log) : log.info.bind(log);
+    return (client) => {
+        client.beforeRequest((req) => {
+            timers.set(req, performance.now());
+            const logData = {
+                type: 'request',
+                method: req.method,
+                url: req.url,
+            };
+            if (showHeaders) {
+                const headers = {};
+                req.headers.forEach((v, k) => {
+                    if (k.toLowerCase() === 'authorization') {
+                        headers[k] = '[REDACTED]';
+                    }
+                    else {
+                        headers[k] = v;
+                    }
+                });
+                logData.headers = headers;
+            }
+            if (showBody && req.body) {
+                if (typeof req.body === 'string') {
+                    try {
+                        logData.body = JSON.parse(req.body);
+                    }
+                    catch {
+                        logData.body = req.body;
+                    }
+                }
+                else {
+                    logData.body = '[Stream/Binary]';
+                }
+            }
+            logFn(logData, `→ ${req.method} ${req.url}`);
+        });
+        client.afterResponse((req, res) => {
+            const start = timers.get(req);
+            const duration = start ? Math.round(performance.now() - start) : 0;
+            const logData = {
+                type: 'response',
+                method: req.method,
+                url: req.url,
+                status: res.status,
+                statusText: res.statusText,
+                ok: res.ok,
+                duration,
+            };
+            if (showHeaders) {
+                const headers = {};
+                res.headers.forEach((v, k) => (headers[k] = v));
+                logData.headers = headers;
+            }
+            if (showTimings && res.timings) {
+                logData.timings = res.timings;
+            }
+            const contentLength = res.headers.get('content-length');
+            if (contentLength) {
+                logData.size = parseInt(contentLength, 10);
+            }
+            logFn(logData, `← ${res.status} ${req.method} ${req.url} (${duration}ms)`);
+        });
+        client.onError((err, req) => {
+            const start = timers.get(req);
+            const duration = start ? Math.round(performance.now() - start) : 0;
+            log.error({
+                type: 'error',
+                method: req.method,
+                url: req.url,
+                error: err.message,
+                errorName: err.name,
+                duration,
+            }, `✖ ${req.method} ${req.url} - ${err.message}`);
+        });
+    };
+}
+export function toCurl(req) {
+    const parts = ['curl'];
+    if (req.method !== 'GET') {
+        parts.push(`-X ${req.method}`);
+    }
+    parts.push(`'${req.url}'`);
+    req.headers.forEach((value, key) => {
+        const displayValue = key.toLowerCase() === 'authorization' ? '[REDACTED]' : value;
+        parts.push(`-H '${key}: ${displayValue}'`);
+    });
+    if (req.body) {
+        if (typeof req.body === 'string') {
+            parts.push(`-d '${req.body}'`);
+        }
+        else if (req.body instanceof URLSearchParams) {
+            parts.push(`-d '${req.body.toString()}'`);
+        }
+        else {
+            parts.push(`-d '[Body]'`);
+        }
+    }
+    return parts.join(' \\\n  ');
+}
+export { consoleLogger, silentLogger, createLevelLogger } from '../types/logger.js';

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

@@ -0,0 +1,181 @@
+import type { Client } from '../core/client.js';
+import type { RequestOptions } from '../types/index.js';
+export interface ODataOptions {
+    serviceRoot: string;
+    version?: '4.0' | '4.01';
+    maxPageSize?: number;
+    requestOptions?: RequestOptions;
+}
+export interface ODataQueryOptions {
+    $select?: string | string[];
+    $expand?: string | string[] | ExpandOption[];
+    $filter?: string | FilterExpression;
+    $orderby?: string | OrderByOption[];
+    $top?: number;
+    $skip?: number;
+    $count?: boolean;
+    $search?: string;
+    $format?: 'json' | 'xml' | 'atom';
+    [key: string]: unknown;
+}
+export interface ExpandOption {
+    property: string;
+    select?: string[];
+    expand?: ExpandOption[];
+    filter?: string | FilterExpression;
+    orderby?: string | OrderByOption[];
+    top?: number;
+    skip?: number;
+    count?: boolean;
+}
+export interface OrderByOption {
+    property: string;
+    direction?: 'asc' | 'desc';
+}
+export interface FilterExpression {
+    and?: FilterExpression[];
+    or?: FilterExpression[];
+    not?: FilterExpression;
+    eq?: [string, unknown];
+    ne?: [string, unknown];
+    gt?: [string, unknown];
+    ge?: [string, unknown];
+    lt?: [string, unknown];
+    le?: [string, unknown];
+    contains?: [string, string];
+    startswith?: [string, string];
+    endswith?: [string, string];
+    raw?: string;
+}
+export interface ODataResponse<T = unknown> {
+    '@odata.context'?: string;
+    '@odata.count'?: number;
+    '@odata.nextLink'?: string;
+    value?: T[];
+    [key: string]: unknown;
+}
+export interface ODataEntityResponse<T = unknown> extends ODataResponse<T> {
+    '@odata.etag'?: string;
+}
+export interface ODataError {
+    error: {
+        code: string;
+        message: string;
+        target?: string;
+        details?: Array<{
+            code: string;
+            message: string;
+            target?: string;
+        }>;
+        innererror?: {
+            message?: string;
+            type?: string;
+            stacktrace?: string;
+        };
+    };
+}
+export declare class ODataException extends Error {
+    readonly code: string;
+    readonly target?: string;
+    readonly details?: Array<{
+        code: string;
+        message: string;
+        target?: string;
+    }>;
+    readonly innererror?: {
+        message?: string;
+        type?: string;
+        stacktrace?: string;
+    };
+    constructor(error: ODataError['error']);
+}
+export declare class ODataQueryBuilder<T = unknown> {
+    private client;
+    private entitySet;
+    private entityKey?;
+    private queryOptions;
+    private requestOptions?;
+    constructor(client: ODataClient, entitySet: string);
+    key(key: string | number | Record<string, unknown>): this;
+    select(...properties: string[]): this;
+    expand(...properties: (string | ExpandOption)[]): this;
+    filter(filter: string | FilterExpression | ((builder: FilterBuilder) => FilterBuilder)): this;
+    orderBy(property: string, direction?: 'asc' | 'desc'): this;
+    top(count: number): this;
+    skip(count: number): this;
+    count(include?: boolean): this;
+    search(term: string): this;
+    custom(key: string, value: unknown): this;
+    options(options: RequestOptions): this;
+    get(): Promise<ODataResponse<T>>;
+    getAll(): AsyncGenerator<T, void, unknown>;
+    toUrl(): string;
+}
+export declare class FilterBuilder {
+    private parts;
+    eq(property: string, value: unknown): this;
+    ne(property: string, value: unknown): this;
+    gt(property: string, value: unknown): this;
+    ge(property: string, value: unknown): this;
+    lt(property: string, value: unknown): this;
+    le(property: string, value: unknown): this;
+    contains(property: string, value: string): this;
+    startswith(property: string, value: string): this;
+    endswith(property: string, value: string): this;
+    isNull(property: string): this;
+    isNotNull(property: string): this;
+    in(property: string, values: unknown[]): this;
+    and(): this;
+    or(): this;
+    not(): this;
+    group(builder: (b: FilterBuilder) => FilterBuilder): this;
+    raw(expression: string): this;
+    build(): string;
+    private formatValue;
+    private escapeString;
+}
+export declare class ODataClient {
+    private client;
+    private options;
+    constructor(client: Client, options: ODataOptions);
+    query<T = unknown>(entitySet: string): ODataQueryBuilder<T>;
+    get<T = unknown>(entitySet: string, key?: string | number | Record<string, unknown>, queryOptions?: ODataQueryOptions, requestOptions?: RequestOptions): Promise<ODataResponse<T>>;
+    getById<T = unknown>(entitySet: string, key: string | number | Record<string, unknown>, queryOptions?: ODataQueryOptions, requestOptions?: RequestOptions): Promise<T>;
+    getNextPage<T = unknown>(nextLink: string): Promise<ODataResponse<T>>;
+    create<T = unknown>(entitySet: string, entity: Partial<T>, requestOptions?: RequestOptions): Promise<T>;
+    update<T = unknown>(entitySet: string, key: string | number | Record<string, unknown>, entity: Partial<T>, requestOptions?: RequestOptions): Promise<T>;
+    replace<T = unknown>(entitySet: string, key: string | number | Record<string, unknown>, entity: T, requestOptions?: RequestOptions): Promise<T>;
+    delete(entitySet: string, key: string | number | Record<string, unknown>, requestOptions?: RequestOptions): Promise<void>;
+    action<T = unknown>(action: string, params?: Record<string, unknown>, requestOptions?: RequestOptions): Promise<T>;
+    function<T = unknown>(func: string, params?: Record<string, unknown>, requestOptions?: RequestOptions): Promise<T>;
+    batch(requests: Array<{
+        method: string;
+        url: string;
+        body?: unknown;
+        headers?: Record<string, string>;
+    }>, requestOptions?: RequestOptions): Promise<Array<{
+        status: number;
+        body: unknown;
+    }>>;
+    getMetadata(): Promise<string>;
+    buildUrl(entitySet: string, key?: string | number | Record<string, unknown>, queryOptions?: ODataQueryOptions): string;
+    private getHeaders;
+    private request;
+    private handleResponse;
+    private formatKey;
+    private formatKeyValue;
+    private buildQueryString;
+    private formatExpand;
+    private formatExpandOption;
+    private formatOrderBy;
+    private formatFilterExpression;
+    private formatFilterValue;
+    private parseBatchResponse;
+}
+export declare function createODataClient(client: Client, options: ODataOptions): ODataClient;
+export declare function odata(): (client: Client) => void;
+declare module '../core/client.js' {
+    interface Client {
+        odata(serviceRoot: string, options?: Omit<ODataOptions, 'serviceRoot'>): ODataClient;
+    }
+}