@opra/client 0.21.0 → 0.23.0

package/types/{http/http-collection-node.d.ts → collection-node.d.ts}

@@ -1,10 +1,10 @@
 import { StrictOmit } from 'ts-gems';
 import type { PartialInput } from '@opra/common';
 import { OpraFilter } from '@opra/common';
-import { kHttpClientContext } from '../constants.js';
+import { kContext } from './constants.js';
 import { HttpRequestObservable } from './http-request-observable.js';
 import { HttpResponse } from './http-response.js';
-import { HttpClientContext, HttpEvent } from './http-types.js';
+import { HttpClientContext, HttpEvent, HttpObserveType } from './types.js';
 export declare namespace HttpCollectionNode {
     interface CreateOptions extends HttpRequestObservable.Options {
         pick?: string[];
@@ -48,70 +48,70 @@ export declare namespace HttpCollectionNode {
     }
 }
 export declare class HttpCollectionNode<TType, TResponseExt = {}> {
-    protected [kHttpClientContext]: HttpClientContext;
+    protected [kContext]: HttpClientContext;
     constructor(context: HttpClientContext);
     create(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.CreateOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     create(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.CreateOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     create(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.CreateOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     delete(id: any, options?: StrictOmit<HttpCollectionNode.DeleteOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<never, never, TResponseExt>;
     delete(id: any, options?: StrictOmit<HttpCollectionNode.DeleteOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<never>, never, TResponseExt>;
     delete(id: any, options?: StrictOmit<HttpCollectionNode.DeleteOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, never, TResponseExt>;
     deleteMany(options?: StrictOmit<HttpCollectionNode.DeleteManyOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<HttpCollectionNode.DeleteManyBody, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     deleteMany(options?: StrictOmit<HttpCollectionNode.DeleteManyOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<HttpCollectionNode.DeleteManyBody>, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     deleteMany(options?: StrictOmit<HttpCollectionNode.DeleteManyOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     get(id: any, options?: StrictOmit<HttpCollectionNode.GetOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     get(id: any, options?: StrictOmit<HttpCollectionNode.GetOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     get(id: any, options?: StrictOmit<HttpCollectionNode.GetOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'>): HttpRequestObservable<TType[], TType, TResponseExt>;
     findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType[], TType, TResponseExt>;
     findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType[]>, TType, TResponseExt>;
     findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     update(id: any, data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     update(id: any, data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     update(id: any, data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     updateMany(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateManyOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<HttpCollectionNode.UpdateManyBody, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     updateMany(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateManyOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<HttpCollectionNode.UpdateManyBody>, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     updateMany(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateManyOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, HttpCollectionNode.UpdateManyBody, TResponseExt>;
 }

package/types/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const JSON_CONTENT_TYPE_PATTERN: RegExp;
 export declare const TEXT_CONTENT_TYPE_PATTERN: RegExp;
 export declare const FORMDATA_CONTENT_TYPE_PATTERN: RegExp;
-export declare const kHttpClientContext: unique symbol;
+export declare const kRequest: unique symbol;
+export declare const kContext: unique symbol;

package/types/{http/http-request-observable.d.ts → http-request-observable.d.ts}

@@ -1,28 +1,23 @@
 import { Observable } from 'rxjs';
-import { ClientHttpHeaders } from '@opra/common';
-import { kHttpClientContext } from '../constants.js';
+import { kContext, kRequest } from './constants.js';
 import { HttpRequest } from './http-request.js';
 import { HttpResponse } from './http-response.js';
-import { HttpClientContext, HttpRequestDefaults, ObserveType } from './http-types.js';
-declare const kRequest: unique symbol;
+import { HttpClientContext, HttpObserveType, HttpRequestDefaults } from './types.js';
 export declare namespace HttpRequestObservable {
     interface Options {
-        observe?: ObserveType;
+        observe?: HttpObserveType;
         http?: HttpRequestDefaults;
     }
 }
 export declare class HttpRequestObservable<T, TBody, TResponseExt = {}> extends Observable<T> {
-    static kContext: symbol;
-    static kRequest: symbol;
     readonly contentId: string;
-    protected [kHttpClientContext]: HttpClientContext;
+    protected [kContext]: HttpClientContext;
     protected [kRequest]: HttpRequest;
     constructor(context: HttpClientContext, options?: HttpRequestObservable.Options);
-    header<K extends keyof ClientHttpHeaders>(name: K, value: ClientHttpHeaders[K]): this;
+    header(name: string, value: string | string[]): this;
     param(name: string, value: any): this;
     fetch(): Promise<TBody>;
-    fetch(observe: 'body'): Promise<TBody>;
-    fetch(observe: 'response'): Promise<HttpResponse<TBody> & TResponseExt>;
+    fetch(observe: HttpObserveType.Body): Promise<TBody>;
+    fetch(observe: HttpObserveType.Response): Promise<HttpResponse<TBody> & TResponseExt>;
     with(cb: (_this: this) => void): this;
 }
-export {};

package/types/{http/http-request.d.ts → http-request.d.ts}

@@ -1,5 +1,6 @@
 /// <reference lib="dom" />
-import { HttpParams, OpraURL, OpraURLPath } from '@opra/common';
+import { OpraURL } from '@opra/common';
+import { URLSearchParamsInit } from './types.js';
 export declare namespace HttpRequest {
     interface Initiator {
         cache?: RequestCache;
@@ -10,7 +11,7 @@ export declare namespace HttpRequest {
         keepalive?: boolean;
         method?: string;
         mode?: RequestMode;
-        params?: HttpParams.Initiator;
+        params?: URLSearchParamsInit;
         redirect?: RequestRedirect;
         referrer?: string;
         referrerPolicy?: ReferrerPolicy;
@@ -58,18 +59,16 @@ export declare class HttpRequest {
      *  whether or not request has been aborted, and its abort event handler. */
     signal?: AbortSignal;
     /** Returns the parsed url as OpraURL instance */
-    readonly urlInstance: OpraURL;
+    parsedUrl: OpraURL;
     /** Body of the http request */
     body?: any;
     duplex?: 'half';
     constructor(init?: HttpRequest.Initiator);
     /** Returns the URL of request as a string. */
-    get url(): string;
-    set url(value: string);
+    get url(): OpraURL;
+    set url(value: OpraURL);
     /** Returns the searchParams of the URL as OpraURLSearchParams */
-    get params(): HttpParams;
-    /** Returns the path part of URL as OpraURLPath */
-    get path(): OpraURLPath;
+    get params(): URLSearchParams;
     clone(...update: (HttpRequest | HttpRequest.Initiator)[]): HttpRequest;
     merge(update: HttpRequest | HttpRequest.Initiator): void;
     inset(src: HttpRequest | HttpRequest.Initiator): void;

package/types/{http/http-response.d.ts → http-response.d.ts}

@@ -6,7 +6,7 @@ export declare namespace HttpResponse {
         url?: string;
         body?: any;
         hasBody?: boolean;
-        totalMatches?: number;
+        totalCount?: number;
     }
 }
 export declare class HttpResponse<TBody = any> {
@@ -34,7 +34,7 @@ export declare class HttpResponse<TBody = any> {
      * Body contents
      */
     readonly body: TBody | null;
-    readonly totalMatches?: number;
+    readonly totalCount?: number;
     /**
      * Returns true if response has body to be received
      */

package/types/{http/http-service-base.d.ts → http-service-base.d.ts}

@@ -1,4 +1,4 @@
-import { OpraHttpClient } from './http-client.js';
+import { OpraHttpClient } from './client.js';
 export declare class HttpServiceBase {
     $client: OpraHttpClient;
     constructor($client: OpraHttpClient);

package/types/index.d.ts

@@ -1,9 +1,9 @@
+export * from './client.js';
 export * from './client-error.js';
-export * from './http/http-client.js';
-export * from './http/http-collection-node.js';
-export * from './http/http-request.js';
-export * from './http/http-request-observable.js';
-export * from './http/http-response.js';
-export * from './http/http-service-base.js';
-export * from './http/http-singleton-node.js';
-export * from './http/http-types.js';
+export * from './collection-node.js';
+export * from './http-request.js';
+export * from './http-request-observable.js';
+export * from './http-response.js';
+export * from './http-service-base.js';
+export * from './singleton-node.js';
+export * from './types.js';

package/types/{http/http-singleton-node.d.ts → singleton-node.d.ts}

@@ -1,9 +1,9 @@
 import { StrictOmit } from 'ts-gems';
 import { PartialInput } from '@opra/common';
-import { kHttpClientContext } from '../constants.js';
+import { kContext } from './constants.js';
 import { HttpRequestObservable } from './http-request-observable.js';
 import { HttpResponse } from './http-response.js';
-import { HttpClientContext, HttpEvent } from './http-types.js';
+import { HttpClientContext, HttpEvent, HttpObserveType } from './types.js';
 export declare namespace HttpSingletonNode {
     interface CreateOptions extends HttpRequestObservable.Options {
         pick?: string[];
@@ -24,42 +24,42 @@ export declare namespace HttpSingletonNode {
     }
 }
 export declare class HttpSingletonNode<TType, TResponseExt = {}> {
-    protected [kHttpClientContext]: HttpClientContext;
+    protected [kContext]: HttpClientContext;
     constructor(context: HttpClientContext);
     create(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.CreateOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     create(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.CreateOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     create(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.CreateOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     delete(options?: StrictOmit<HttpSingletonNode.DeleteOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<never, never, TResponseExt>;
     delete(options?: StrictOmit<HttpSingletonNode.DeleteOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<never>, never, TResponseExt>;
     delete(options?: StrictOmit<HttpSingletonNode.DeleteOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, never, TResponseExt>;
     get(options?: StrictOmit<HttpSingletonNode.GetOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     get(options?: StrictOmit<HttpSingletonNode.GetOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     get(options?: StrictOmit<HttpSingletonNode.GetOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     update(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.UpdateOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     update(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.UpdateOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     update(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.UpdateOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
 }

package/types/types.d.ts

@@ -0,0 +1,114 @@
+import type { Observable } from 'rxjs';
+import type { OpraSchema } from '@opra/common';
+import type { OpraHttpClient } from './client';
+import type { HttpRequest } from './http-request.js';
+import type { HttpResponse } from './http-response.js';
+export type HttpRequestHandler = (observe: HttpObserveType, request: HttpRequest) => Observable<any>;
+export type RequestInterceptor = (ctx: HttpClientContext, request: HttpRequest) => void | Promise<void>;
+export type ResponseInterceptor = ((ctx: HttpClientContext, observe: HttpObserveType, response: any) => void | Promise<void>);
+export type HttpEvent = HttpSentEvent | HttpDownloadProgressEvent | HttpUploadProgressEvent | HttpResponseHeaderEvent | HttpResponseEvent | HttpUserEvent;
+export type URLSearchParamsInit = string[][] | Record<string, string> | string | URLSearchParams;
+export declare enum HttpObserveType {
+    Response = "response",
+    Body = "body",
+    Events = "events"
+}
+/**
+ * Type enumeration for the different kinds of `HttpEvent`.
+ */
+export declare enum HttpEventType {
+    /**
+     * The request was sent out over the wire.
+     */
+    Sent = "sent",
+    /**
+     * An upload progress event was received.
+     *
+     * Note: The `FetchBackend` doesn't support progress report on uploads.
+     */
+    UploadProgress = "upload-progress",
+    /**
+     * The response status code and headers were received.
+     */
+    ResponseHeader = "response-header",
+    /**
+     * A download progress event was received.
+     */
+    DownloadProgress = "download-progress",
+    /**
+     * The full response including the body was received.
+     */
+    Response = "response",
+    /**
+     * A custom event from an interceptor or a backend.
+     */
+    Custom = "custom"
+}
+export interface HttpClientContext {
+    client: OpraHttpClient;
+    resourceKind: OpraSchema.Resource.Kind;
+    resourceName: string;
+    operation: string;
+    send: HttpRequestHandler;
+    requestInterceptors?: RequestInterceptor[];
+    responseInterceptors?: ResponseInterceptor[];
+}
+export interface HttpRequestDefaults extends Partial<Pick<HttpRequest, 'cache' | 'credentials' | 'destination' | 'integrity' | 'keepalive' | 'mode' | 'redirect' | 'referrer' | 'referrerPolicy'>> {
+    headers?: HeadersInit;
+    params?: URLSearchParamsInit;
+}
+interface HttpEventBase {
+    observe: HttpObserveType;
+    request: HttpRequest;
+    event: HttpEventType;
+}
+export interface HttpSentEvent extends HttpEventBase {
+    event: HttpEventType.Sent;
+}
+export interface HttpDownloadProgressEvent extends HttpEventBase {
+    event: HttpEventType.DownloadProgress;
+    /**
+     * Number of bytes uploaded
+     */
+    loaded: number;
+    /**
+     * Total number of bytes to upload.
+     * Depending on the request, this may not be computable and thus may not be present.
+     */
+    total?: number;
+}
+export interface HttpUploadProgressEvent extends HttpEventBase {
+    event: HttpEventType.UploadProgress;
+    /**
+     * Response object
+     */
+    response: HttpResponse;
+    /**
+     * Number of bytes uploaded
+     */
+    loaded: number;
+    /**
+     * Total number of bytes to upload.
+     * Depending on the request, this may not be computable and thus may not be present.
+     */
+    total?: number;
+}
+export interface HttpResponseHeaderEvent extends HttpEventBase {
+    event: HttpEventType.ResponseHeader;
+    /**
+     * Response object
+     */
+    response: HttpResponse;
+}
+export interface HttpResponseEvent extends HttpEventBase {
+    event: HttpEventType.Response;
+    /**
+     * Response object
+     */
+    response: HttpResponse;
+}
+export interface HttpUserEvent extends HttpEventBase {
+    event: HttpEventType.Custom;
+    [key: string | number | symbol]: any;
+}
+export {};

package/cjs/http/http-collection-node.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpCollectionNode = void 0;
-const constants_js_1 = require("../constants.js");
-const http_request_observable_js_1 = require("./http-request-observable.js");
-class HttpCollectionNode {
-    constructor(context) {
-        this[constants_js_1.kHttpClientContext] = context;
-    }
-    create(data, options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'POST';
-        request.url = context.resourceName;
-        request.body = data;
-        if (options?.include)
-            request.params.set('$include', options.include);
-        if (options?.pick)
-            request.params.set('$pick', options.pick);
-        if (options?.omit)
-            request.params.set('$omit', options.omit);
-        return requestHost;
-    }
-    delete(id, options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'DELETE';
-        request.path.join({ resource: context.resourceName, key: id });
-        return requestHost;
-    }
-    deleteMany(options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'DELETE';
-        request.url = context.resourceName;
-        if (options?.filter)
-            request.params.set('$filter', options.filter);
-        return requestHost;
-    }
-    get(id, options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'GET';
-        request.path.join({ resource: context.resourceName, key: id });
-        if (options?.include)
-            request.params.set('$include', options.include);
-        if (options?.pick)
-            request.params.set('$pick', options.pick);
-        if (options?.omit)
-            request.params.set('$omit', options.omit);
-        return requestHost;
-    }
-    findMany(options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'GET';
-        request.url = context.resourceName;
-        if (options?.include)
-            request.params.set('$include', options.include);
-        if (options?.pick)
-            request.params.set('$pick', options.pick);
-        if (options?.omit)
-            request.params.set('$omit', options.omit);
-        if (options?.sort)
-            request.params.set('$sort', options.sort);
-        if (options?.filter)
-            request.params.set('$filter', options.filter);
-        if (options?.limit != null)
-            request.params.set('$limit', options.limit);
-        if (options?.skip != null)
-            request.params.set('$skip', options.skip);
-        if (options?.count != null)
-            request.params.set('$count', options.count);
-        if (options?.distinct != null)
-            request.params.set('$distinct', options.distinct);
-        return requestHost;
-    }
-    update(id, data, options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'PATCH';
-        request.path.join({ resource: context.resourceName, key: id });
-        request.body = data;
-        if (options?.include)
-            request.params.set('$include', options.include);
-        if (options?.pick)
-            request.params.set('$pick', options.pick);
-        if (options?.omit)
-            request.params.set('$omit', options.omit);
-        return requestHost;
-    }
-    updateMany(data, options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'PATCH';
-        request.url = context.resourceName;
-        request.body = data;
-        if (options?.filter)
-            request.params.set('$filter', options.filter);
-        return requestHost;
-    }
-}
-exports.HttpCollectionNode = HttpCollectionNode;

package/cjs/http/http-singleton-node.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpSingletonNode = void 0;
-const constants_js_1 = require("../constants.js");
-const http_request_observable_js_1 = require("./http-request-observable.js");
-class HttpSingletonNode {
-    constructor(context) {
-        this[constants_js_1.kHttpClientContext] = context;
-    }
-    create(data, options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'POST';
-        request.url = context.resourceName;
-        request.body = data;
-        if (options?.include)
-            request.params.set('$include', options.include);
-        if (options?.pick)
-            request.params.set('$pick', options.pick);
-        if (options?.omit)
-            request.params.set('$omit', options.omit);
-        return requestHost;
-    }
-    delete(options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'DELETE';
-        request.path.join({ resource: context.resourceName });
-        return requestHost;
-    }
-    get(options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'GET';
-        request.path.join({ resource: context.resourceName });
-        if (options?.include)
-            request.params.set('$include', options.include);
-        if (options?.pick)
-            request.params.set('$pick', options.pick);
-        if (options?.omit)
-            request.params.set('$omit', options.omit);
-        return requestHost;
-    }
-    update(data, options) {
-        const context = this[constants_js_1.kHttpClientContext];
-        const requestHost = new http_request_observable_js_1.HttpRequestObservable(context, options);
-        const request = requestHost[http_request_observable_js_1.HttpRequestObservable.kRequest];
-        request.method = 'PATCH';
-        request.path.join({ resource: context.resourceName });
-        request.body = data;
-        if (options?.include)
-            request.params.set('$include', options.include);
-        if (options?.pick)
-            request.params.set('$pick', options.pick);
-        if (options?.omit)
-            request.params.set('$omit', options.omit);
-        return requestHost;
-    }
-}
-exports.HttpSingletonNode = HttpSingletonNode;

package/cjs/http/http-types.js

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