@opra/client 0.4.0 → 0.6.0

package/cjs/http/utils/merge-raw-http-requests.util.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeRawHttpRequests = void 0;
+const common_1 = require("@opra/common");
+function mergeRawHttpRequests(target, ...other) {
+    let params;
+    const arr = [target, ...other];
+    let headers;
+    for (let i = arr.length - 1; i >= 0; i--) {
+        const o = arr[i];
+        if (o?.headers) {
+            headers = headers || {};
+            Object.assign(headers, (0, common_1.normalizeHeaders)(o.headers));
+        }
+    }
+    for (const o of arr) {
+        if (!o)
+            continue;
+        Object.assign(target, o);
+        if (o?.params) {
+            params = params || new common_1.OpraURLSearchParams();
+            o.params.forEach((v, n) => params?.append(n, v));
+        }
+    }
+    target.headers = headers;
+    target.params = params;
+    return target;
+}
+exports.mergeRawHttpRequests = mergeRawHttpRequests;

package/cjs/index.js

@@ -1,8 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./client.js"), exports);
-tslib_1.__exportStar(require("./response.js"), exports);
+tslib_1.__exportStar(require("./http/http-client.js"), exports);
+tslib_1.__exportStar(require("./http/http-request.js"), exports);
+tslib_1.__exportStar(require("./http/http-response.js"), exports);
+tslib_1.__exportStar(require("./http/http-collection-service.js"), exports);
+tslib_1.__exportStar(require("./http/http-singleton-service.js"), exports);
+tslib_1.__exportStar(require("./http/http-types.js"), exports);
 tslib_1.__exportStar(require("./types.js"), exports);
-tslib_1.__exportStar(require("./services/collection-service.js"), exports);
-tslib_1.__exportStar(require("./services/singleton-service.js"), exports);
+tslib_1.__exportStar(require("./client-error.js"), exports);
+tslib_1.__exportStar(require("./http/requests/batch-request.js"), exports);
+tslib_1.__exportStar(require("./http/requests/collection-create-request.js"), exports);
+tslib_1.__exportStar(require("./http/requests/collection-delete-request.js"), exports);
+tslib_1.__exportStar(require("./http/requests/collection-delete-many-request.js"), exports);
+tslib_1.__exportStar(require("./http/requests/collection-get-request.js"), exports);
+tslib_1.__exportStar(require("./http/requests/collection-search-request.js"), exports);
+tslib_1.__exportStar(require("./http/requests/collection-update-request.js"), exports);
+tslib_1.__exportStar(require("./http/requests/collection-update-many-request.js"), exports);
+tslib_1.__exportStar(require("./http/requests/http-singleton-get-request.js"), exports);

package/cjs/interfaces/http-options.interface.js

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

package/cjs/interfaces/http-request-config.interface.js

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

package/cjs/types.js

@@ -1,11 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// export type CollectionCreateRequestOptions = CollectionCreateQueryOptions & CommonRequestOptions;
-// export type CollectionDeleteRequestOptions = CommonRequestOptions;
-// export type CollectionDeleteManyRequestOptions = CollectionDeleteManyQueryOptions & CommonRequestOptions;
-// export type CollectionGetRequestOptions = CollectionGetQueryOptions & CommonRequestOptions;
-// export type CollectionUpdateRequestOptions = CollectionUpdateQueryOptions & CommonRequestOptions;
-// export type CollectionUpdateManyRequestOptions = CollectionUpdateManyQueryOptions & CommonRequestOptions;
-// export type CollectionSearchRequestOptions = CollectionSearchQueryOptions & CommonRequestOptions;
-//
-// export type SingletonGetRequestOptions = SingletonGetQueryOptions & CommonRequestOptions;

package/esm/client-error.d.ts

@@ -1,4 +1,4 @@
-import { ErrorIssue } from '@opra/exception';
+import { ErrorIssue } from '@opra/common';
 export declare class ClientError extends Error {
     cause?: Error | undefined;
     issues: ErrorIssue[];

package/esm/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const JSON_CONTENT_TYPE_PATTERN: RegExp;
+export declare const TEXT_CONTENT_TYPE_PATTERN: RegExp;
+export declare const FORMDATA_CONTENT_TYPE_PATTERN: RegExp;

package/esm/constants.js

@@ -0,0 +1,3 @@
+export const JSON_CONTENT_TYPE_PATTERN = /^application\/([\w-]+\+)?\bjson\b/i;
+export const TEXT_CONTENT_TYPE_PATTERN = /^text\/.*$/i;
+export const FORMDATA_CONTENT_TYPE_PATTERN = /^multipart\/\bform-data\b/i;

package/esm/http/http-client.d.ts

@@ -0,0 +1,26 @@
+import { Type } from 'ts-gems';
+import { OpraDocument } from '@opra/common';
+import { HttpCollectionService } from './http-collection-service.js';
+import { HttpRequest } from './http-request.js';
+import { HttpResponse } from './http-response.js';
+import { HttpSingletonService } from './http-singleton-service.js';
+import { HttpRequestDefaults, OpraHttpClientOptions, RawHttpRequest } from './http-types.js';
+import { BatchRequest } from './requests/batch-request.js';
+export declare class OpraHttpClient {
+    protected _serviceUrl: string;
+    protected _metadata?: OpraDocument;
+    defaults: HttpRequestDefaults;
+    constructor(serviceUrl: string, options?: OpraHttpClientOptions);
+    get serviceUrl(): string;
+    get initialized(): boolean;
+    get metadata(): OpraDocument;
+    init(forceRefresh?: boolean): Promise<void>;
+    batch(requests: HttpRequest[]): BatchRequest;
+    collection<T = any>(name: string | Type<T>): HttpCollectionService<T>;
+    singleton<T = any>(name: string | Type<T>): HttpSingletonService<T>;
+    protected _resolveMetadata(): Promise<void>;
+    protected _handleRequest<TResponse extends HttpResponse = HttpResponse>(req: RawHttpRequest): Promise<TResponse>;
+    protected _fetch<TResponse extends HttpResponse = HttpResponse>(url: string, req: RequestInit): Promise<TResponse>;
+    protected _assertMetadata(): void;
+    static create<T extends OpraHttpClient>(this: Type<T>, serviceUrl: string, options?: OpraHttpClientOptions): Promise<T>;
+}

package/esm/http/http-client.js

@@ -0,0 +1,160 @@
+import { isReadable, isReadableStream, joinPath, OpraDocument } from '@opra/common';
+import { ClientError } from '../client-error.js';
+import { FORMDATA_CONTENT_TYPE_PATTERN, JSON_CONTENT_TYPE_PATTERN, TEXT_CONTENT_TYPE_PATTERN } from '../constants.js';
+import { HttpCollectionService } from './http-collection-service.js';
+import { HttpSingletonService } from './http-singleton-service.js';
+import { BatchRequest } from './requests/batch-request.js';
+import { mergeRawHttpRequests } from './utils/merge-raw-http-requests.util.js';
+const documentCache = new Map();
+const documentResolverCaches = new Map();
+export class OpraHttpClient {
+    _serviceUrl;
+    _metadata;
+    defaults;
+    constructor(serviceUrl, options) {
+        this._serviceUrl = serviceUrl;
+        this._metadata = options?.document;
+        if (!this._metadata) {
+            const document = documentCache.get(this.serviceUrl.toLowerCase());
+            if (document)
+                this._metadata = document;
+        }
+        this.defaults = options?.defaults || {};
+    }
+    get serviceUrl() {
+        return this._serviceUrl;
+    }
+    get initialized() {
+        return !!this._metadata;
+    }
+    get metadata() {
+        this._assertMetadata();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this._metadata;
+    }
+    async init(forceRefresh) {
+        if (!forceRefresh && this.initialized)
+            return;
+        const cacheName = this.serviceUrl.toLowerCase();
+        let promise = documentResolverCaches.get(cacheName);
+        if (promise) {
+            await promise;
+            return;
+        }
+        promise = this._resolveMetadata();
+        documentResolverCaches.set(cacheName, promise);
+        return promise
+            .catch(() => void 0)
+            .finally(() => documentResolverCaches.delete(cacheName));
+    }
+    batch(requests) {
+        this._assertMetadata();
+        return new BatchRequest(req => this._handleRequest(req), requests);
+    }
+    collection(name) {
+        this._assertMetadata();
+        // If name argument is a class, we extract name from the class
+        if (typeof name === 'function')
+            name = name.name;
+        const resource = this.metadata.getCollectionResource(name);
+        return new HttpCollectionService(resource, req => this._handleRequest(req));
+    }
+    singleton(name) {
+        this._assertMetadata();
+        // If name argument is a class, we extract name from the class
+        if (typeof name === 'function')
+            name = name.name;
+        const resource = this.metadata.getSingletonResource(name);
+        return new HttpSingletonService(resource, req => this._handleRequest(req));
+    }
+    async _resolveMetadata() {
+        const resp = await this._handleRequest({
+            method: 'GET',
+            path: '/$metadata',
+            headers: { 'accept': 'application/json' }
+        });
+        this._metadata = new OpraDocument(resp.data);
+    }
+    async _handleRequest(req) {
+        mergeRawHttpRequests(req, this.defaults);
+        let url = joinPath(this.serviceUrl, req.path);
+        if (req.params)
+            url += '?' + req.params.toString();
+        if (req.body) {
+            if (typeof req.body === 'object') {
+                if (!(isReadable(req.body) || isReadableStream(req.body) || Buffer.isBuffer(req.body))) {
+                    if (!req.headers?.['content-type']) {
+                        req.headers = req.headers || {};
+                        req.headers['content-type'] = 'application/json';
+                    }
+                    req.body = JSON.stringify(req.body);
+                }
+            }
+        }
+        return this._fetch(url, req);
+    }
+    async _fetch(url, req) {
+        const resp = await fetch(url, req);
+        let data;
+        if (resp.body) {
+            if (JSON_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || '')) {
+                data = await resp.json();
+                if (typeof data === 'string')
+                    data = JSON.parse(data);
+            }
+            else if (TEXT_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || ''))
+                data = await resp.text();
+            else if (FORMDATA_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || ''))
+                data = await resp.formData();
+            else
+                data = await resp.arrayBuffer();
+        }
+        if (resp.status >= 400 && resp.status < 600) {
+            throw new ClientError({
+                message: resp.status + ' ' + resp.statusText,
+                status: resp.status,
+                issues: data?.errors
+            });
+        }
+        const out = {
+            get headers() {
+                return resp.headers;
+            },
+            get ok() {
+                return resp.ok;
+            },
+            get redirected() {
+                return resp.redirected;
+            },
+            get status() {
+                return resp.status;
+            },
+            get statusText() {
+                return resp.statusText;
+            },
+            get type() {
+                return resp.type;
+            },
+            get url() {
+                return resp.url;
+            },
+            get contentId() {
+                return resp.headers.get('Content-ID');
+            },
+            get data() {
+                return data;
+            }
+        };
+        return out;
+    }
+    _assertMetadata() {
+        if (!this._metadata)
+            throw new Error('You must call init() to before using the client instance');
+    }
+    static async create(serviceUrl, options) {
+        const client = new this(serviceUrl, options);
+        if (!client._metadata)
+            await client.init();
+        return client;
+    }
+}

package/esm/http/http-collection-service.d.ts

@@ -0,0 +1,22 @@
+import type { CollectionCreateQueryOptions, CollectionDeleteManyQueryOptions, CollectionGetQueryOptions, CollectionResourceInfo, CollectionSearchQueryOptions, CollectionUpdateManyQueryOptions, CollectionUpdateQueryOptions, PartialInput } from '@opra/common';
+import { HttpResponse } from './http-response.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from './http-types.js';
+import { CollectionCreateRequest } from './requests/collection-create-request.js';
+import { CollectionDeleteManyRequest } from './requests/collection-delete-many-request.js';
+import { CollectionDeleteRequest } from './requests/collection-delete-request.js';
+import { CollectionGetRequest } from './requests/collection-get-request.js';
+import { CollectionSearchRequest } from './requests/collection-search-request.js';
+import { CollectionUpdateManyRequest } from './requests/collection-update-many-request.js';
+import { CollectionUpdateRequest } from './requests/collection-update-request.js';
+export declare class HttpCollectionService<T, TResponse extends HttpResponse<T> = HttpResponse<T>> {
+    readonly resource: CollectionResourceInfo;
+    protected _handler: HttpRequestHandler;
+    constructor(resource: CollectionResourceInfo, _handler: HttpRequestHandler);
+    create(data: PartialInput<T>, options?: CollectionCreateQueryOptions & CommonHttpRequestOptions): CollectionCreateRequest<T, TResponse>;
+    delete(keyValue: any, options?: CommonHttpRequestOptions): CollectionDeleteRequest<T, TResponse>;
+    deleteMany(options?: CollectionDeleteManyQueryOptions & CommonHttpRequestOptions): CollectionDeleteManyRequest<T, TResponse>;
+    get(keyValue: any, options?: CollectionGetQueryOptions & CommonHttpRequestOptions): CollectionGetRequest<T, TResponse>;
+    search(options?: CollectionSearchQueryOptions & CommonHttpRequestOptions): CollectionSearchRequest<T, TResponse>;
+    update(keyValue: any, data: PartialInput<T>, options?: CollectionUpdateQueryOptions & CommonHttpRequestOptions): CollectionUpdateRequest<T, TResponse>;
+    updateMany(data: PartialInput<T>, options?: CollectionUpdateManyQueryOptions & CommonHttpRequestOptions): CollectionUpdateManyRequest<T, TResponse>;
+}

package/esm/http/http-collection-service.js

@@ -0,0 +1,36 @@
+import { CollectionCreateRequest } from './requests/collection-create-request.js';
+import { CollectionDeleteManyRequest } from './requests/collection-delete-many-request.js';
+import { CollectionDeleteRequest } from './requests/collection-delete-request.js';
+import { CollectionGetRequest } from './requests/collection-get-request.js';
+import { CollectionSearchRequest } from './requests/collection-search-request.js';
+import { CollectionUpdateManyRequest } from './requests/collection-update-many-request.js';
+import { CollectionUpdateRequest } from './requests/collection-update-request.js';
+export class HttpCollectionService {
+    resource;
+    _handler;
+    constructor(resource, _handler) {
+        this.resource = resource;
+        this._handler = _handler;
+    }
+    create(data, options) {
+        return new CollectionCreateRequest(this._handler, this.resource, data, options);
+    }
+    delete(keyValue, options) {
+        return new CollectionDeleteRequest(this._handler, this.resource, keyValue, options);
+    }
+    deleteMany(options) {
+        return new CollectionDeleteManyRequest(this._handler, this.resource, options);
+    }
+    get(keyValue, options) {
+        return new CollectionGetRequest(this._handler, this.resource, keyValue, options);
+    }
+    search(options) {
+        return new CollectionSearchRequest(this._handler, this.resource, options);
+    }
+    update(keyValue, data, options) {
+        return new CollectionUpdateRequest(this._handler, this.resource, keyValue, data, options);
+    }
+    updateMany(data, options) {
+        return new CollectionUpdateManyRequest(this._handler, this.resource, data, options);
+    }
+}

package/esm/http/http-request.d.ts

@@ -0,0 +1,25 @@
+import { Observable } from 'rxjs';
+import { ClientHttpHeaders } from '@opra/common';
+import { HttpResponse } from './http-response.js';
+import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from './http-types.js';
+export declare abstract class HttpRequest<TResult = any, TResponse extends HttpResponse<TResult> = HttpResponse<TResult>> extends Observable<TResult | TResponse> {
+    protected _handler: HttpRequestHandler<TResult>;
+    options: CommonHttpRequestOptions;
+    readonly contentId: string;
+    protected _promise?: Promise<TResponse>;
+    protected _headers?: ClientHttpHeaders;
+    protected constructor(_handler: HttpRequestHandler<TResult>, options?: CommonHttpRequestOptions);
+    abstract prepare(): RawHttpRequest;
+    header<K extends keyof ClientHttpHeaders>(name: K, value: ClientHttpHeaders[K]): this;
+    /**
+     * Sends the request
+     */
+    fetch(): Promise<TResponse>;
+    /**
+     * Sends the request and returns response data
+     */
+    resolve(): Promise<TResult | undefined>;
+    with(cb: (_this: this) => void): this;
+    binding(): any;
+    protected _execute(): Promise<TResponse>;
+}

package/esm/http/http-request.js

@@ -0,0 +1,62 @@
+import { Observable } from 'rxjs';
+import { uid } from '@opra/common';
+export class HttpRequest extends Observable {
+    _handler;
+    options;
+    contentId;
+    _promise;
+    _headers;
+    constructor(_handler, options = {}) {
+        super((subscriber) => {
+            if (options.observe === 'response') {
+                this.fetch().then(v => {
+                    subscriber.next(v);
+                    subscriber.complete();
+                }).catch(e => subscriber.error(e));
+                return;
+            }
+            this.resolve().then(v => {
+                subscriber.next(v);
+                subscriber.complete();
+            }).catch(e => subscriber.error(e));
+        });
+        this._handler = _handler;
+        this.options = options;
+        this.contentId = uid(6);
+        this.options = options;
+    }
+    header(name, value) {
+        this._headers = this._headers || {};
+        this._headers[name] = value;
+        return this;
+    }
+    /**
+     * Sends the request
+     */
+    async fetch() {
+        const promise = this._promise || (this._promise = new Promise((resolve, reject) => {
+            setTimeout(() => {
+                this._execute().then(resolve).catch(reject);
+            }, 0);
+        }));
+        return await promise;
+    }
+    /**
+     * Sends the request and returns response data
+     */
+    async resolve() {
+        const resp = await this.fetch();
+        return resp.data;
+    }
+    with(cb) {
+        cb(this);
+        return this;
+    }
+    binding() {
+        return {};
+    }
+    async _execute() {
+        const req = this.prepare();
+        return await this._handler(req);
+    }
+}

package/esm/http/http-response.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Opra Client Response Class
+ */
+export interface HttpResponse<TData = any> {
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly redirected: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly type: ResponseType;
+    readonly url: string;
+    readonly contentId?: string | null;
+    readonly data: TData;
+}

package/esm/http/http-singleton-service.d.ts

@@ -0,0 +1,10 @@
+import { SingletonGetQueryOptions, SingletonResourceInfo } from '@opra/common';
+import { HttpResponse } from './http-response.js';
+import { HttpRequestHandler } from './http-types.js';
+import { HttpSingletonGetRequest } from './requests/http-singleton-get-request.js';
+export declare class HttpSingletonService<T, TResponse extends HttpResponse<T> = HttpResponse<T>> {
+    readonly resource: SingletonResourceInfo;
+    protected _handler: HttpRequestHandler;
+    constructor(resource: SingletonResourceInfo, _handler: HttpRequestHandler);
+    get(options?: SingletonGetQueryOptions): HttpSingletonGetRequest<T, TResponse>;
+}

package/esm/http/http-singleton-service.js

@@ -0,0 +1,12 @@
+import { HttpSingletonGetRequest } from './requests/http-singleton-get-request.js';
+export class HttpSingletonService {
+    resource;
+    _handler;
+    constructor(resource, _handler) {
+        this.resource = resource;
+        this._handler = _handler;
+    }
+    get(options) {
+        return new HttpSingletonGetRequest(this._handler, this.resource, options);
+    }
+}

package/esm/http/http-types.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+/// <reference lib="dom" />
+import { StrictOmit } from 'ts-gems';
+import { URLSearchParams } from 'url';
+import { ClientHttpHeaders, OpraDocument, OpraURLSearchParams } from '@opra/common';
+import type { HttpResponse } from './http-response';
+export declare type CommonHttpRequestOptions = {
+    observe?: 'body' | 'response';
+    http?: HttpRequestDefaults;
+};
+export declare type RawHttpRequest = StrictOmit<RequestInit, 'headers' | 'body' | 'method'> & {
+    method: string;
+    path: string;
+    headers?: ClientHttpHeaders;
+    params?: URLSearchParams | OpraURLSearchParams;
+    body?: any;
+};
+export declare type HttpRequestDefaults = Pick<RawHttpRequest, 'headers' | 'params' | 'mode' | 'credentials' | 'cache' | 'redirect' | 'referrer' | 'referrerPolicy' | 'integrity' | 'keepalive' | 'signal'>;
+export declare type HttpRequestHandler<TResult = any> = (req: RawHttpRequest) => Promise<HttpResponse<TResult>>;
+export interface OpraHttpClientOptions {
+    /**
+     * Opra Service Metadata Document
+     */
+    document?: OpraDocument;
+    defaults?: HttpRequestDefaults;
+}

package/esm/http/http-types.js

@@ -0,0 +1 @@
+export {};

package/esm/http/requests/batch-request.d.ts

@@ -0,0 +1,18 @@
+import { BatchMultipart } from '@opra/common';
+import { HttpRequest } from '../http-request.js';
+import { HttpResponse } from '../http-response.js';
+import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
+export declare class BatchRequest extends HttpRequest {
+    protected _handler: HttpRequestHandler;
+    readonly requests: HttpRequest[];
+    options: CommonHttpRequestOptions;
+    protected _results: WeakMap<HttpRequest<any, HttpResponse<any>>, {
+        error?: Error | undefined;
+        response?: HttpResponse<any> | undefined;
+    }>;
+    protected _listeners: Set<(error: Error | undefined, response?: HttpResponse) => void>;
+    constructor(_handler: HttpRequestHandler, requests: HttpRequest[], options?: CommonHttpRequestOptions);
+    prepare(): RawHttpRequest;
+    protected _buildBatchMultipart(batch: BatchRequest): BatchMultipart;
+    protected _execute(): Promise<HttpResponse>;
+}

package/esm/http/requests/batch-request.js

@@ -0,0 +1,76 @@
+import { BatchMultipart } from '@opra/common';
+import { HttpRequest } from '../http-request.js';
+import { mergeRawHttpRequests } from '../utils/merge-raw-http-requests.util.js';
+export class BatchRequest extends HttpRequest {
+    _handler;
+    requests;
+    options;
+    _results = new WeakMap();
+    _listeners = new Set();
+    constructor(_handler, requests, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.requests = requests;
+        this.options = options;
+        requests.forEach(request => {
+            // Overwrite the _execute method
+            Object.defineProperty(request, '_execute', {
+                writable: true,
+                enumerable: false,
+                configurable: true,
+                value: () => {
+                    return new Promise((resolve, reject) => {
+                        const x = this._results.get(request);
+                        if (x) {
+                            if (x.error)
+                                return reject(x.error);
+                            return resolve(x.response);
+                        }
+                        const callback = (error, response) => {
+                            this._listeners.delete(callback);
+                            if (error)
+                                return reject(error);
+                            resolve(response);
+                        };
+                        this._listeners.add(callback);
+                    });
+                }
+            });
+        });
+    }
+    prepare() {
+        const batch = this._buildBatchMultipart(this);
+        const headers = {
+            'content-type': 'multipart/mixed;boundary=' + batch.boundary
+        };
+        return mergeRawHttpRequests({
+            method: 'POST',
+            path: '/$batch',
+            headers,
+            body: batch.stream()
+        }, this.options.http);
+    }
+    _buildBatchMultipart(batch) {
+        const multipart = new BatchMultipart();
+        for (const req of batch.requests) {
+            const prepared = req.prepare();
+            if (req instanceof BatchRequest) {
+                const subMultipart = this._buildBatchMultipart(req);
+                multipart.addBatch(subMultipart);
+                continue;
+            }
+            multipart.addRequestPart({
+                method: prepared.method,
+                url: prepared.path,
+                headers: prepared.headers,
+                data: prepared.body
+            });
+        }
+        return multipart;
+    }
+    async _execute() {
+        const req = this.prepare();
+        const resp = await this._handler(req);
+        return resp;
+    }
+}

package/esm/http/requests/collection-create-request.d.ts

@@ -0,0 +1,12 @@
+import { CollectionCreateQueryOptions, CollectionResourceInfo, PartialInput } from '@opra/common';
+import { HttpRequest } from '../http-request.js';
+import { HttpResponse } from '../http-response.js';
+import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
+export declare class CollectionCreateRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
+    protected _handler: HttpRequestHandler;
+    readonly resource: CollectionResourceInfo;
+    data: PartialInput<T>;
+    options: CollectionCreateQueryOptions & CommonHttpRequestOptions;
+    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, data: PartialInput<T>, options?: CollectionCreateQueryOptions & CommonHttpRequestOptions);
+    prepare(): RawHttpRequest;
+}

package/esm/http/requests/collection-create-request.js

@@ -0,0 +1,31 @@
+import { OpraURLSearchParams } from '@opra/common';
+import { HttpRequest } from '../http-request.js';
+import { mergeRawHttpRequests } from '../utils/merge-raw-http-requests.util.js';
+export class CollectionCreateRequest extends HttpRequest {
+    _handler;
+    resource;
+    data;
+    options;
+    constructor(_handler, resource, data, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.data = data;
+        this.options = options;
+    }
+    prepare() {
+        const searchParams = new OpraURLSearchParams();
+        if (this.options.include)
+            searchParams.set('$include', this.options.include);
+        if (this.options.pick)
+            searchParams.set('$pick', this.options.pick);
+        if (this.options.omit)
+            searchParams.set('$omit', this.options.omit);
+        return mergeRawHttpRequests({
+            method: 'POST',
+            path: this.resource.name,
+            params: searchParams,
+            body: this.data,
+        }, this.options.http);
+    }
+}

package/esm/http/requests/collection-delete-many-request.d.ts

@@ -0,0 +1,11 @@
+import { CollectionDeleteManyQueryOptions, CollectionResourceInfo } from '@opra/common';
+import { HttpRequest } from '../http-request.js';
+import { HttpResponse } from '../http-response.js';
+import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
+export declare class CollectionDeleteManyRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
+    protected _handler: HttpRequestHandler;
+    readonly resource: CollectionResourceInfo;
+    options: CollectionDeleteManyQueryOptions & CommonHttpRequestOptions;
+    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, options?: CollectionDeleteManyQueryOptions & CommonHttpRequestOptions);
+    prepare(): RawHttpRequest;
+}