recker 1.0.26 → 1.0.27

package/dist/browser/plugins/odata.js

@@ -0,0 +1,564 @@
+import { UnsupportedError, HttpError } from '../core/errors.js';
+export class ODataException extends Error {
+    code;
+    target;
+    details;
+    innererror;
+    constructor(error) {
+        super(error.message);
+        this.name = 'ODataException';
+        this.code = error.code;
+        this.target = error.target;
+        this.details = error.details;
+        this.innererror = error.innererror;
+    }
+}
+export class ODataQueryBuilder {
+    client;
+    entitySet;
+    entityKey;
+    queryOptions = {};
+    requestOptions;
+    constructor(client, entitySet) {
+        this.client = client;
+        this.entitySet = entitySet;
+    }
+    key(key) {
+        this.entityKey = key;
+        return this;
+    }
+    select(...properties) {
+        this.queryOptions.$select = properties;
+        return this;
+    }
+    expand(...properties) {
+        const hasExpandOptions = properties.some((p) => typeof p !== 'string');
+        if (hasExpandOptions) {
+            this.queryOptions.$expand = properties;
+        }
+        else {
+            this.queryOptions.$expand = properties;
+        }
+        return this;
+    }
+    filter(filter) {
+        if (typeof filter === 'function') {
+            const builder = new FilterBuilder();
+            this.queryOptions.$filter = filter(builder).build();
+        }
+        else {
+            this.queryOptions.$filter = filter;
+        }
+        return this;
+    }
+    orderBy(property, direction = 'asc') {
+        const existing = this.queryOptions.$orderby;
+        const option = { property, direction };
+        if (Array.isArray(existing)) {
+            existing.push(option);
+        }
+        else if (existing) {
+            this.queryOptions.$orderby = [{ property: existing, direction: 'asc' }, option];
+        }
+        else {
+            this.queryOptions.$orderby = [option];
+        }
+        return this;
+    }
+    top(count) {
+        this.queryOptions.$top = count;
+        return this;
+    }
+    skip(count) {
+        this.queryOptions.$skip = count;
+        return this;
+    }
+    count(include = true) {
+        this.queryOptions.$count = include;
+        return this;
+    }
+    search(term) {
+        this.queryOptions.$search = term;
+        return this;
+    }
+    custom(key, value) {
+        this.queryOptions[key] = value;
+        return this;
+    }
+    options(options) {
+        this.requestOptions = options;
+        return this;
+    }
+    async get() {
+        return this.client.get(this.entitySet, this.entityKey, this.queryOptions, this.requestOptions);
+    }
+    async *getAll() {
+        let response = await this.get();
+        while (response.value) {
+            for (const item of response.value) {
+                yield item;
+            }
+            if (response['@odata.nextLink']) {
+                response = await this.client.getNextPage(response['@odata.nextLink']);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    toUrl() {
+        return this.client.buildUrl(this.entitySet, this.entityKey, this.queryOptions);
+    }
+}
+export class FilterBuilder {
+    parts = [];
+    eq(property, value) {
+        this.parts.push(`${property} eq ${this.formatValue(value)}`);
+        return this;
+    }
+    ne(property, value) {
+        this.parts.push(`${property} ne ${this.formatValue(value)}`);
+        return this;
+    }
+    gt(property, value) {
+        this.parts.push(`${property} gt ${this.formatValue(value)}`);
+        return this;
+    }
+    ge(property, value) {
+        this.parts.push(`${property} ge ${this.formatValue(value)}`);
+        return this;
+    }
+    lt(property, value) {
+        this.parts.push(`${property} lt ${this.formatValue(value)}`);
+        return this;
+    }
+    le(property, value) {
+        this.parts.push(`${property} le ${this.formatValue(value)}`);
+        return this;
+    }
+    contains(property, value) {
+        this.parts.push(`contains(${property},'${this.escapeString(value)}')`);
+        return this;
+    }
+    startswith(property, value) {
+        this.parts.push(`startswith(${property},'${this.escapeString(value)}')`);
+        return this;
+    }
+    endswith(property, value) {
+        this.parts.push(`endswith(${property},'${this.escapeString(value)}')`);
+        return this;
+    }
+    isNull(property) {
+        this.parts.push(`${property} eq null`);
+        return this;
+    }
+    isNotNull(property) {
+        this.parts.push(`${property} ne null`);
+        return this;
+    }
+    in(property, values) {
+        const formatted = values.map((v) => this.formatValue(v)).join(',');
+        this.parts.push(`${property} in (${formatted})`);
+        return this;
+    }
+    and() {
+        if (this.parts.length > 0) {
+            this.parts.push('and');
+        }
+        return this;
+    }
+    or() {
+        if (this.parts.length > 0) {
+            this.parts.push('or');
+        }
+        return this;
+    }
+    not() {
+        this.parts.push('not');
+        return this;
+    }
+    group(builder) {
+        const inner = new FilterBuilder();
+        const result = builder(inner).build();
+        this.parts.push(`(${result})`);
+        return this;
+    }
+    raw(expression) {
+        this.parts.push(expression);
+        return this;
+    }
+    build() {
+        return this.parts.join(' ');
+    }
+    formatValue(value) {
+        if (value === null)
+            return 'null';
+        if (typeof value === 'string')
+            return `'${this.escapeString(value)}'`;
+        if (typeof value === 'boolean')
+            return value.toString();
+        if (typeof value === 'number')
+            return value.toString();
+        if (value instanceof Date)
+            return value.toISOString();
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    }
+    escapeString(str) {
+        return str.replace(/'/g, "''");
+    }
+}
+export class ODataClient {
+    client;
+    options;
+    constructor(client, options) {
+        this.client = client;
+        this.options = {
+            serviceRoot: options.serviceRoot.replace(/\/$/, ''),
+            version: options.version ?? '4.0',
+            maxPageSize: options.maxPageSize ?? 100,
+            requestOptions: options.requestOptions ?? {},
+        };
+    }
+    query(entitySet) {
+        return new ODataQueryBuilder(this, entitySet);
+    }
+    async get(entitySet, key, queryOptions, requestOptions) {
+        const url = this.buildUrl(entitySet, key, queryOptions);
+        const response = await this.request('GET', url, undefined, requestOptions);
+        return response;
+    }
+    async getById(entitySet, key, queryOptions, requestOptions) {
+        const response = await this.get(entitySet, key, queryOptions, requestOptions);
+        return response;
+    }
+    async getNextPage(nextLink) {
+        const response = await this.client.get(nextLink, {
+            ...this.options.requestOptions,
+            headers: this.getHeaders(),
+        });
+        return this.handleResponse(response);
+    }
+    async create(entitySet, entity, requestOptions) {
+        const url = this.buildUrl(entitySet);
+        return this.request('POST', url, entity, requestOptions);
+    }
+    async update(entitySet, key, entity, requestOptions) {
+        const url = this.buildUrl(entitySet, key);
+        return this.request('PATCH', url, entity, requestOptions);
+    }
+    async replace(entitySet, key, entity, requestOptions) {
+        const url = this.buildUrl(entitySet, key);
+        return this.request('PUT', url, entity, requestOptions);
+    }
+    async delete(entitySet, key, requestOptions) {
+        const url = this.buildUrl(entitySet, key);
+        await this.request('DELETE', url, undefined, requestOptions);
+    }
+    async action(action, params, requestOptions) {
+        const url = `${this.options.serviceRoot}/${action}`;
+        return this.request('POST', url, params, requestOptions);
+    }
+    async function(func, params, requestOptions) {
+        let url = `${this.options.serviceRoot}/${func}`;
+        if (params && Object.keys(params).length > 0) {
+            const paramString = Object.entries(params)
+                .map(([k, v]) => `${k}=${this.formatKeyValue(v)}`)
+                .join(',');
+            url += `(${paramString})`;
+        }
+        return this.request('GET', url, undefined, requestOptions);
+    }
+    async batch(requests, requestOptions) {
+        const boundary = `batch_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        const batchUrl = `${this.options.serviceRoot}/$batch`;
+        let body = '';
+        for (const req of requests) {
+            body += `--${boundary}\r\n`;
+            body += 'Content-Type: application/http\r\n';
+            body += 'Content-Transfer-Encoding: binary\r\n\r\n';
+            body += `${req.method} ${req.url} HTTP/1.1\r\n`;
+            if (req.headers) {
+                for (const [key, value] of Object.entries(req.headers)) {
+                    body += `${key}: ${value}\r\n`;
+                }
+            }
+            if (req.body) {
+                body += 'Content-Type: application/json\r\n\r\n';
+                body += JSON.stringify(req.body);
+            }
+            body += '\r\n';
+        }
+        body += `--${boundary}--\r\n`;
+        const response = await this.client.post(batchUrl, body, {
+            ...this.options.requestOptions,
+            ...requestOptions,
+            headers: {
+                ...this.getHeaders(),
+                'Content-Type': `multipart/mixed; boundary=${boundary}`,
+                ...requestOptions?.headers,
+            },
+        });
+        const responseText = await response.text();
+        return this.parseBatchResponse(responseText);
+    }
+    async getMetadata() {
+        const response = await this.client.get(`${this.options.serviceRoot}/$metadata`, {
+            ...this.options.requestOptions,
+            headers: {
+                Accept: 'application/xml',
+            },
+        });
+        return response.text();
+    }
+    buildUrl(entitySet, key, queryOptions) {
+        let url = `${this.options.serviceRoot}/${entitySet}`;
+        if (key !== undefined) {
+            url += `(${this.formatKey(key)})`;
+        }
+        if (queryOptions) {
+            const params = this.buildQueryString(queryOptions);
+            if (params) {
+                url += `?${params}`;
+            }
+        }
+        return url;
+    }
+    getHeaders() {
+        return {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'OData-Version': this.options.version,
+            'OData-MaxVersion': '4.01',
+        };
+    }
+    async request(method, url, body, requestOptions) {
+        const options = {
+            ...this.options.requestOptions,
+            ...requestOptions,
+            throwHttpErrors: false,
+            headers: {
+                ...this.getHeaders(),
+                ...requestOptions?.headers,
+            },
+        };
+        let response;
+        switch (method) {
+            case 'GET':
+                response = await this.client.get(url, options);
+                break;
+            case 'POST':
+                response = await this.client.post(url, body, options);
+                break;
+            case 'PUT':
+                response = await this.client.put(url, body, options);
+                break;
+            case 'PATCH':
+                response = await this.client.patch(url, body, options);
+                break;
+            case 'DELETE':
+                response = await this.client.delete(url, options);
+                break;
+            default:
+                throw new UnsupportedError(`Unsupported HTTP method: ${method}`, {
+                    feature: method,
+                });
+        }
+        return this.handleResponse(response);
+    }
+    async handleResponse(response) {
+        if (response.status === 204) {
+            return undefined;
+        }
+        const data = await response.json();
+        if (!response.ok) {
+            const error = data;
+            if (error.error) {
+                throw new ODataException(error.error);
+            }
+            throw new HttpError(response);
+        }
+        return data;
+    }
+    formatKey(key) {
+        if (typeof key === 'string') {
+            return `'${key.replace(/'/g, "''")}'`;
+        }
+        if (typeof key === 'number') {
+            return key.toString();
+        }
+        return Object.entries(key)
+            .map(([k, v]) => `${k}=${this.formatKeyValue(v)}`)
+            .join(',');
+    }
+    formatKeyValue(value) {
+        if (typeof value === 'string')
+            return `'${value.replace(/'/g, "''")}'`;
+        if (value === null)
+            return 'null';
+        if (value instanceof Date)
+            return value.toISOString();
+        return String(value);
+    }
+    buildQueryString(options) {
+        const params = [];
+        if (options.$select) {
+            const select = Array.isArray(options.$select) ? options.$select.join(',') : options.$select;
+            params.push(`$select=${encodeURIComponent(select)}`);
+        }
+        if (options.$expand) {
+            const expand = this.formatExpand(options.$expand);
+            params.push(`$expand=${encodeURIComponent(expand)}`);
+        }
+        if (options.$filter) {
+            const filter = typeof options.$filter === 'string'
+                ? options.$filter
+                : this.formatFilterExpression(options.$filter);
+            params.push(`$filter=${encodeURIComponent(filter)}`);
+        }
+        if (options.$orderby) {
+            const orderby = this.formatOrderBy(options.$orderby);
+            params.push(`$orderby=${encodeURIComponent(orderby)}`);
+        }
+        if (options.$top !== undefined) {
+            params.push(`$top=${options.$top}`);
+        }
+        if (options.$skip !== undefined) {
+            params.push(`$skip=${options.$skip}`);
+        }
+        if (options.$count !== undefined) {
+            params.push(`$count=${options.$count}`);
+        }
+        if (options.$search) {
+            params.push(`$search=${encodeURIComponent(options.$search)}`);
+        }
+        if (options.$format) {
+            params.push(`$format=${options.$format}`);
+        }
+        for (const [key, value] of Object.entries(options)) {
+            if (!key.startsWith('$') && value !== undefined) {
+                params.push(`${key}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        return params.join('&');
+    }
+    formatExpand(expand) {
+        if (typeof expand === 'string')
+            return expand;
+        if (Array.isArray(expand)) {
+            return expand.map((e) => {
+                if (typeof e === 'string')
+                    return e;
+                return this.formatExpandOption(e);
+            }).join(',');
+        }
+        return '';
+    }
+    formatExpandOption(option) {
+        let result = option.property;
+        const nested = [];
+        if (option.select)
+            nested.push(`$select=${option.select.join(',')}`);
+        if (option.filter) {
+            const filter = typeof option.filter === 'string'
+                ? option.filter
+                : this.formatFilterExpression(option.filter);
+            nested.push(`$filter=${filter}`);
+        }
+        if (option.orderby)
+            nested.push(`$orderby=${this.formatOrderBy(option.orderby)}`);
+        if (option.top !== undefined)
+            nested.push(`$top=${option.top}`);
+        if (option.skip !== undefined)
+            nested.push(`$skip=${option.skip}`);
+        if (option.count !== undefined)
+            nested.push(`$count=${option.count}`);
+        if (option.expand)
+            nested.push(`$expand=${this.formatExpand(option.expand)}`);
+        if (nested.length > 0) {
+            result += `(${nested.join(';')})`;
+        }
+        return result;
+    }
+    formatOrderBy(orderby) {
+        if (typeof orderby === 'string')
+            return orderby;
+        return orderby.map((o) => `${o.property} ${o.direction ?? 'asc'}`).join(',');
+    }
+    formatFilterExpression(filter) {
+        if (filter.raw)
+            return filter.raw;
+        const parts = [];
+        if (filter.eq)
+            parts.push(`${filter.eq[0]} eq ${this.formatFilterValue(filter.eq[1])}`);
+        if (filter.ne)
+            parts.push(`${filter.ne[0]} ne ${this.formatFilterValue(filter.ne[1])}`);
+        if (filter.gt)
+            parts.push(`${filter.gt[0]} gt ${this.formatFilterValue(filter.gt[1])}`);
+        if (filter.ge)
+            parts.push(`${filter.ge[0]} ge ${this.formatFilterValue(filter.ge[1])}`);
+        if (filter.lt)
+            parts.push(`${filter.lt[0]} lt ${this.formatFilterValue(filter.lt[1])}`);
+        if (filter.le)
+            parts.push(`${filter.le[0]} le ${this.formatFilterValue(filter.le[1])}`);
+        if (filter.contains)
+            parts.push(`contains(${filter.contains[0]},'${filter.contains[1]}')`);
+        if (filter.startswith)
+            parts.push(`startswith(${filter.startswith[0]},'${filter.startswith[1]}')`);
+        if (filter.endswith)
+            parts.push(`endswith(${filter.endswith[0]},'${filter.endswith[1]}')`);
+        if (filter.and) {
+            const andParts = filter.and.map((f) => this.formatFilterExpression(f));
+            parts.push(`(${andParts.join(' and ')})`);
+        }
+        if (filter.or) {
+            const orParts = filter.or.map((f) => this.formatFilterExpression(f));
+            parts.push(`(${orParts.join(' or ')})`);
+        }
+        if (filter.not) {
+            parts.push(`not (${this.formatFilterExpression(filter.not)})`);
+        }
+        return parts.join(' and ');
+    }
+    formatFilterValue(value) {
+        if (value === null)
+            return 'null';
+        if (typeof value === 'string')
+            return `'${value.replace(/'/g, "''")}'`;
+        if (typeof value === 'boolean')
+            return value.toString();
+        if (typeof value === 'number')
+            return value.toString();
+        if (value instanceof Date)
+            return value.toISOString();
+        return String(value);
+    }
+    parseBatchResponse(responseText) {
+        const results = [];
+        const boundaryMatch = responseText.match(/--batch[^\r\n]+/);
+        if (!boundaryMatch)
+            return results;
+        const boundary = boundaryMatch[0];
+        const parts = responseText.split(boundary).slice(1, -1);
+        for (const part of parts) {
+            const statusMatch = part.match(/HTTP\/\d\.\d\s+(\d+)/);
+            const bodyMatch = part.match(/\r\n\r\n({[\s\S]*})/);
+            results.push({
+                status: statusMatch ? parseInt(statusMatch[1], 10) : 0,
+                body: bodyMatch ? JSON.parse(bodyMatch[1]) : null,
+            });
+        }
+        return results;
+    }
+}
+export function createODataClient(client, options) {
+    return new ODataClient(client, options);
+}
+export function odata() {
+    return (client) => {
+        client.odata = (serviceRoot, options) => {
+            return createODataClient(client, { serviceRoot, ...options });
+        };
+    };
+}

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

@@ -0,0 +1,16 @@
+import { ReckerResponse, PageResult } from '../types/index.js';
+interface IClient {
+    request(url: string, options?: any): Promise<ReckerResponse>;
+}
+export interface PaginationOptions<T = any> {
+    getItems?: (data: any) => T[];
+    getNextUrl?: (response: ReckerResponse, data: any, currentUrl: string) => string | null;
+    maxPages?: number;
+    pageParam?: string;
+    limitParam?: string;
+    resultsPath?: string;
+    nextCursorPath?: string;
+}
+export declare function streamPages<T = any>(client: IClient, url: string, requestOptions?: any, paginationOptions?: PaginationOptions): AsyncGenerator<PageResult<T>>;
+export declare function paginate<T>(client: IClient, url: string, requestOptions?: any, paginationOptions?: PaginationOptions<T>): AsyncGenerator<T>;
+export {};

package/dist/browser/plugins/pagination.js

@@ -0,0 +1,105 @@
+export async function* streamPages(client, url, requestOptions = {}, paginationOptions = {}) {
+    let currentUrl = url;
+    let pageCount = 1;
+    const maxPages = paginationOptions.maxPages || Infinity;
+    while (currentUrl && pageCount <= maxPages) {
+        const response = await client.request(currentUrl, { ...requestOptions, method: 'GET' });
+        const data = await response.json();
+        yield {
+            data,
+            response,
+            pageNumber: pageCount
+        };
+        pageCount++;
+        if (paginationOptions.getNextUrl) {
+            currentUrl = paginationOptions.getNextUrl(response, data, currentUrl);
+            continue;
+        }
+        if (paginationOptions.nextCursorPath) {
+            const parts = paginationOptions.nextCursorPath.split('.');
+            let cursor = data;
+            for (const part of parts) {
+                if (cursor && typeof cursor === 'object') {
+                    cursor = cursor[part];
+                }
+                else {
+                    cursor = undefined;
+                    break;
+                }
+            }
+            if (cursor) {
+                const cursorParamName = paginationOptions.pageParam || 'cursor';
+                const isAbsolute = currentUrl.startsWith('http');
+                const urlObj = new URL(isAbsolute ? currentUrl : `http://dummy-base${currentUrl.startsWith('/') ? '' : '/'}${currentUrl}`);
+                urlObj.searchParams.set(cursorParamName, String(cursor));
+                if (isAbsolute) {
+                    currentUrl = urlObj.toString();
+                }
+                else {
+                    currentUrl = urlObj.pathname + urlObj.search;
+                }
+            }
+            else {
+                currentUrl = null;
+            }
+            continue;
+        }
+        if (paginationOptions.pageParam) {
+            const isAbsolute = currentUrl.startsWith('http');
+            const urlObj = new URL(isAbsolute ? currentUrl : `http://dummy-base${currentUrl.startsWith('/') ? '' : '/'}${currentUrl}`);
+            const paramName = paginationOptions.pageParam;
+            const currentVal = parseInt(urlObj.searchParams.get(paramName) || String(pageCount - 1), 10);
+            let isEmpty = false;
+            if (Array.isArray(data) && data.length === 0)
+                isEmpty = true;
+            if (data && Array.isArray(data.data) && data.data.length === 0)
+                isEmpty = true;
+            if (data && Array.isArray(data.items) && data.items.length === 0)
+                isEmpty = true;
+            if (isEmpty) {
+                currentUrl = null;
+            }
+            else {
+                const nextPage = (isNaN(currentVal) ? 1 : currentVal) + 1;
+                urlObj.searchParams.set(paramName, String(nextPage));
+                currentUrl = isAbsolute ? urlObj.toString() : (urlObj.pathname + urlObj.search);
+            }
+            continue;
+        }
+        const linkHeader = response.headers.get('link');
+        if (linkHeader) {
+            const match = linkHeader.match(/<([^>]+)>;\s*rel="next"/);
+            currentUrl = match ? match[1] : null;
+        }
+        else {
+            currentUrl = null;
+        }
+    }
+}
+export async function* paginate(client, url, requestOptions = {}, paginationOptions = {}) {
+    for await (const page of streamPages(client, url, requestOptions, paginationOptions)) {
+        const data = page.data;
+        let items = [];
+        if (paginationOptions.getItems) {
+            items = paginationOptions.getItems(data);
+        }
+        else if (paginationOptions.resultsPath) {
+            items = paginationOptions.resultsPath.split('.').reduce((o, i) => o?.[i], data) || [];
+        }
+        else if (Array.isArray(data)) {
+            items = data;
+        }
+        else if (data && Array.isArray(data.data)) {
+            items = data.data;
+        }
+        else if (data && Array.isArray(data.items)) {
+            items = data.items;
+        }
+        else {
+            items = [data];
+        }
+        for (const item of items) {
+            yield item;
+        }
+    }
+}

package/dist/browser/plugins/rate-limit.d.ts

@@ -0,0 +1,15 @@
+import { Plugin, ReckerRequest } from '../types/index.js';
+export interface RateLimitOptions {
+    limit: number;
+    window?: number;
+    strategy?: 'queue' | 'throw' | 'drop';
+    keyGenerator?: (req: ReckerRequest) => string;
+    adaptive?: boolean;
+}
+export declare class RateLimitExceededError extends Error {
+    limit: number;
+    window: number;
+    key: string;
+    constructor(limit: number, window: number, key: string);
+}
+export declare function rateLimitPlugin(options: RateLimitOptions): Plugin;