@opra/client 0.27.0 → 0.28.0

package/browser.js

@@ -6,24 +6,35 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// ../../build/client/esm/client.js
-import { ApiDocumentFactory } from "@opra/common";
+// ../../build/client/esm/core/backend.js
+var Backend = class {
+  static {
+    __name(this, "Backend");
+  }
+  constructor(options) {
+    this.api = options?.api;
+  }
+};
 
 // ../../build/client/esm/constants.js
 var kClient = Symbol.for("kClient");
+var kBackend = Symbol.for("kBackend");
 var kContext = Symbol.for("kContext");
 
-// ../../build/client/esm/impl/collection-node.js
-import { toArrayDef } from "putil-varhelpers";
-import { OpraURL as OpraURL3 } from "@opra/common";
-
-// ../../build/client/esm/impl/http-request-observable.js
-import { lastValueFrom, Observable } from "rxjs";
-import { isReadableStreamLike } from "rxjs/internal/util/isReadableStreamLike";
-import typeIs from "type-is";
-import { isBlob, OpraURL as OpraURL2 } from "@opra/common";
+// ../../build/client/esm/core/client-base.js
+var ClientBase = class {
+  static {
+    __name(this, "ClientBase");
+  }
+  constructor(backend) {
+    Object.defineProperty(this, kBackend, {
+      enumerable: false,
+      value: backend
+    });
+  }
+};
 
-// ../../build/client/esm/client-error.js
+// ../../build/client/esm/core/client-error.js
 var ClientError = class extends Error {
   static {
     __name(this, "ClientError");
@@ -41,257 +52,218 @@ var ClientError = class extends Error {
   }
 };
 
-// ../../build/client/esm/enums/http-observable-type.enum.js
-var HttpObserveType;
-(function(HttpObserveType2) {
-  HttpObserveType2["ResponseHeader"] = "response-header";
-  HttpObserveType2["Response"] = "response";
-  HttpObserveType2["Body"] = "body";
-  HttpObserveType2["Events"] = "events";
-})(HttpObserveType || (HttpObserveType = {}));
-
-// ../../build/client/esm/interfaces/http-event.interface.js
-var HttpEventType;
-(function(HttpEventType2) {
-  HttpEventType2["Sent"] = "sent";
-  HttpEventType2["UploadProgress"] = "upload-progress";
-  HttpEventType2["ResponseHeader"] = "response-header";
-  HttpEventType2["DownloadProgress"] = "download-progress";
-  HttpEventType2["Response"] = "response";
-  HttpEventType2["Custom"] = "custom";
-})(HttpEventType || (HttpEventType = {}));
+// ../../build/client/esm/http/fetch-backend.js
+import { Observable } from "rxjs";
+import { isReadableStreamLike } from "rxjs/internal/util/isReadableStreamLike";
+import typeIs from "@browsery/type-is";
+import { isBlob } from "@opra/common";
 
-// ../../build/client/esm/impl/http-request.js
-import { OpraURL } from "@opra/common";
-var HttpRequest = class {
+// ../../build/client/esm/http/http-backend.js
+var HttpBackend = class extends Backend {
   static {
-    __name(this, "HttpRequest");
+    __name(this, "HttpBackend");
   }
-  constructor(init) {
-    this.cache = init?.cache || "default";
-    this.credentials = init?.credentials || "same-origin";
-    this.destination = init?.destination || "";
-    this.integrity = init?.integrity || "";
-    this.keepalive = init?.keepalive ?? false;
-    this.method = (init?.method || "GET").toUpperCase();
-    this.mode = init?.mode || "cors";
-    this.redirect = init?.redirect || "follow";
-    this.mode = init?.mode || "cors";
-    this.referrer = init?.referrer || "";
-    this.referrerPolicy = init?.referrerPolicy || "";
-    this.signal = init?.signal || new AbortController().signal;
-    this.body = init?.body;
-    this.url = init?.url instanceof OpraURL ? init.url : new OpraURL(init?.url);
-    this.headers = init?.headers instanceof Headers ? init.headers : new Headers(init?.headers);
+  constructor(serviceUrl, options) {
+    super(options);
+    this.serviceUrl = serviceUrl;
   }
 };
 
-// ../../build/client/esm/impl/http-request-observable.js
-var directCopyProperties = [
-  "cache",
-  "credentials",
-  "destination",
-  "headers",
-  "integrity",
-  "keepalive",
-  "mode",
-  "redirect",
-  "referrer",
-  "referrerPolicy"
-];
-var kIntlObservable = Symbol.for("kIntlObservable");
-var HttpRequestObservable = class extends Observable {
+// ../../build/client/esm/http/http-response.js
+var HttpResponse = class _HttpResponse {
   static {
-    __name(this, "HttpRequestObservable");
-  }
-  constructor(client, init) {
-    super((subscriber) => {
-      this[kIntlObservable].subscribe((event) => {
-        if (event.event === HttpEventType.Response) {
-          subscriber.next(event.response.body);
-          subscriber.complete();
-        }
-      }, (error) => subscriber.error(error), () => subscriber.complete());
-    });
-    Object.defineProperty(this, kClient, {
-      enumerable: false,
-      value: client
-    });
-    this.request = new HttpRequest(init);
-    if (init?.headers)
-      this.header(init.headers);
-    this[kIntlObservable] = this._send();
-  }
-  httpOptions(options) {
-    directCopyProperties.forEach((k) => {
-      if (options[k] !== void 0)
-        this.request[k] = options[k];
-    });
-    return this;
-  }
-  header(arg0, value) {
-    const headers = this.request.headers;
-    if (typeof arg0 === "object") {
-      const h = arg0 instanceof Headers ? arg0 : new Headers(arg0);
-      h.forEach((v, k) => {
-        if (k.toLowerCase() === "set-cookie") {
-          headers.append(k, v);
-        } else
-          headers.set(k, v);
-      });
-      return this;
-    }
-    if (value == null)
-      headers.delete(arg0);
-    else
-      headers.append(arg0, String(value));
-    return this;
-  }
-  param(arg0, value) {
-    const params = this.request.url.searchParams;
-    if (typeof arg0 === "object") {
-      const h = arg0 instanceof URLSearchParams ? arg0 : new URLSearchParams(arg0);
-      h.forEach((v, k) => params.set(k, v));
-      return this;
-    }
-    if (value == null)
-      params.delete(arg0);
-    else
-      params.set(arg0, String(value));
-    return this;
+    __name(this, "HttpResponse");
   }
-  observe(observe) {
-    observe = observe || HttpObserveType.Body;
-    return new Observable((subscriber) => {
-      this[kIntlObservable].subscribe((event) => {
-        if (observe === HttpObserveType.Events) {
-          subscriber.next(event);
-          return;
-        }
-        if (observe === HttpObserveType.ResponseHeader && event.event === HttpEventType.ResponseHeader) {
-          subscriber.next(event.response);
-          subscriber.complete();
-          return;
-        }
-        if (event.event === HttpEventType.Response) {
-          const { response } = event;
-          const isOpraResponse = typeIs.is(event.response.contentType || "", ["application/opra+json"]);
-          if (observe === HttpObserveType.Response) {
-            subscriber.next(response);
-            subscriber.complete();
-            return;
-          }
-          if (response.status >= 400 && response.status < 600) {
-            subscriber.error(new ClientError({
-              message: response.status + " " + response.statusText,
-              status: response.status,
-              issues: isOpraResponse ? response.body.errors : void 0
-            }));
-            subscriber.complete();
-            return;
-          }
-          subscriber.next(event.response.body);
-          subscriber.complete();
-        }
-      }, (error) => subscriber.error(error), () => subscriber.complete());
-    });
+  constructor(init) {
+    this.hasBody = false;
+    this.headers = init?.headers instanceof Headers ? init?.headers : new Headers(init?.headers);
+    this.status = init?.status || 200;
+    this.statusText = init?.statusText || "OK";
+    this.url = init?.url || null;
+    this.ok = this.status >= 200 && this.status < 300;
+    this.body = init?.body;
+    this.hasBody = init?.body != null || !!init?.hasBody;
+    this.contentType = (this.headers.get("content-type") || "").split(";")[0];
   }
-  toPromise() {
-    return this.getBody();
+  clone(update) {
+    return new _HttpResponse({ ...this, ...update });
   }
-  getBody() {
-    return lastValueFrom(this.observe(HttpObserveType.Body));
+};
+
+// ../../build/client/esm/http/interfaces/http-event.js
+var HttpEventType;
+(function(HttpEventType2) {
+  HttpEventType2["Sent"] = "Sent";
+  HttpEventType2["UploadProgress"] = "UploadProgress";
+  HttpEventType2["ResponseHeader"] = "ResponseHeader";
+  HttpEventType2["DownloadProgress"] = "DownloadProgress";
+  HttpEventType2["Response"] = "Response";
+  HttpEventType2["User"] = "User";
+})(HttpEventType || (HttpEventType = {}));
+
+// ../../build/client/esm/http/fetch-backend.js
+var FetchBackend = class extends HttpBackend {
+  static {
+    __name(this, "FetchBackend");
   }
-  getResponse() {
-    return lastValueFrom(this.observe(HttpObserveType.Response));
+  constructor(serviceUrl, options) {
+    super(serviceUrl, options);
+    this.interceptors = Array.from(/* @__PURE__ */ new Set([...options?.interceptors || []]));
+    this.defaults = {
+      ...options?.defaults,
+      headers: options?.defaults?.headers instanceof Headers ? options?.defaults?.headers : new Headers(options?.defaults?.headers),
+      params: options?.defaults?.params instanceof URLSearchParams ? options?.defaults?.params : new URLSearchParams(options?.defaults?.params)
+    };
   }
-  _send() {
-    const request = this.request;
-    const clientContext = this[kClient][kContext];
+  handle(init) {
     return new Observable((subscriber) => {
       (async () => {
-        this._prepareRequest();
-        for (const interceptor of clientContext.requestInterceptors) {
-          await interceptor(request);
+        let request = this.prepareRequest(init);
+        if (request.body && init.reportProgress) {
+          const stream = request.body;
+          const contentLength = request.headers.get("content-length") || "0";
+          const total = parseInt(contentLength, 10) || 0;
+          let loaded = 0;
+          const progressTrackingStream = new TransformStream({
+            transform(chunk, controller) {
+              controller.enqueue(chunk);
+              loaded += chunk.byteLength;
+              subscriber.next({
+                type: HttpEventType.UploadProgress,
+                request,
+                total,
+                loaded
+              });
+            }
+          });
+          request = new Request(request.url, {
+            cache: request.cache,
+            credentials: request.credentials,
+            headers: request.headers,
+            integrity: request.integrity,
+            keepalive: request.keepalive,
+            method: request.method,
+            mode: request.mode,
+            redirect: request.redirect,
+            referrer: request.referrer,
+            referrerPolicy: request.referrerPolicy,
+            signal: request.signal,
+            body: stream.pipeThrough(progressTrackingStream),
+            window: init.window,
+            ...{
+              // undici library requires
+              duplex: "half"
+            }
+          });
         }
+        const fetchPromise = this.send(request);
         subscriber.next({
           request,
-          event: HttpEventType.Sent
+          type: HttpEventType.Sent
         });
-        const url = new OpraURL2(request.url, clientContext.serviceUrl);
-        const fetchResponse = await clientContext.fetch(url.toString(), request);
-        const contentType = (fetchResponse.headers.get("content-type") || "").split(";")[0];
-        const headersResponse = clientContext.createResponse({
+        const fetchResponse = await fetchPromise;
+        const headersResponse = this.createResponse({
           url: fetchResponse.url,
           headers: fetchResponse.headers,
           status: fetchResponse.status,
           statusText: fetchResponse.statusText,
-          hasBody: !!fetchResponse.body,
-          contentType
+          hasBody: !!fetchResponse.body
         });
         subscriber.next({
           request,
-          event: HttpEventType.ResponseHeader,
+          type: HttpEventType.ResponseHeader,
           response: headersResponse
         });
-        const body = fetchResponse.body ? await this._parseBody(fetchResponse) : void 0;
-        const responseInit = {
+        let body;
+        if (fetchResponse.body) {
+          if (init.reportProgress) {
+            const fetchBody = fetchResponse.body;
+            const contentLength = fetchResponse.headers.get("content-length") || "0";
+            const total = parseInt(contentLength, 10) || 0;
+            let loaded = 0;
+            const res = new Response(new ReadableStream({
+              async start(controller) {
+                const reader = fetchBody.getReader();
+                for (; ; ) {
+                  const { done, value } = await reader.read();
+                  if (done)
+                    break;
+                  loaded += value.byteLength;
+                  controller.enqueue(value);
+                  subscriber.next({
+                    type: HttpEventType.DownloadProgress,
+                    request,
+                    total,
+                    loaded
+                  });
+                }
+                controller.close();
+              }
+            }));
+            body = await this.parseBody(res);
+          } else {
+            body = await this.parseBody(fetchResponse);
+          }
+        }
+        const response = this.createResponse({
           url: fetchResponse.url,
           headers: fetchResponse.headers,
           status: fetchResponse.status,
           statusText: fetchResponse.statusText,
-          contentType,
           body
-        };
-        const response = clientContext.createResponse(responseInit);
-        for (const interceptor of clientContext.responseInterceptors) {
-          await interceptor(response, request);
-        }
+        });
         subscriber.next({
           request,
-          event: HttpEventType.Response,
+          type: HttpEventType.Response,
           response
         });
         subscriber.complete();
       })().catch((error) => subscriber.error(error));
     });
   }
-  _prepareRequest() {
-    const request = this.request;
-    if (request.body) {
-      let body;
+  send(request) {
+    return fetch(request);
+  }
+  prepareRequest(init) {
+    const headers = init.headers || new Headers();
+    const requestInit = {
+      ...init,
+      headers
+    };
+    const body = requestInit.body;
+    if (body) {
       let contentType;
-      if (typeof request.body === "string" || typeof request.body === "number" || typeof request.body === "boolean") {
-        contentType = 'text/plain;charset=UTF-8"';
-        body = String(request.body);
-        request.headers.delete("Content-Size");
-        delete request.duplex;
-      } else if (isReadableStreamLike(request.body)) {
+      if (typeof body === "string" || typeof body === "number" || typeof body === "boolean") {
+        contentType = 'text/plain; charset="UTF-8"';
+        requestInit.body = new Blob([String(body)], { type: contentType });
+        headers.set("Content-Length", String(requestInit.body.size));
+        delete requestInit.duplex;
+      } else if (isReadableStreamLike(body)) {
         contentType = "application/octet-stream";
-        body = request.body;
-        request.duplex = "half";
-      } else if (Buffer.isBuffer(request.body)) {
+        requestInit.duplex = "half";
+      } else if (Buffer.isBuffer(body)) {
         contentType = "application/octet-stream";
-        body = request.body;
-        request.headers.set("Content-Size", String(request.body.length));
-        delete request.duplex;
-      } else if (isBlob(request.body)) {
-        contentType = request.body.type || "application/octet-stream";
-        body = request.body;
-        request.headers.set("Content-Size", String(request.body.length));
-        delete request.duplex;
+        headers.set("Content-Length", String(body.length));
+        delete requestInit.duplex;
+      } else if (isBlob(body)) {
+        contentType = body.type || "application/octet-stream";
+        headers.set("Content-Length", String(body.size));
+        delete requestInit.duplex;
       } else {
-        contentType = "application/json";
-        body = JSON.stringify(request.body);
-        request.headers.delete("Content-Size");
-        delete request.duplex;
+        contentType = 'application/json;charset="UTF-8"';
+        requestInit.body = new Blob([JSON.stringify(body)], { type: contentType });
+        headers.set("Content-Length", String(requestInit.body.size));
+        delete requestInit.duplex;
       }
-      if (!request.headers.has("Content-Type") && contentType)
-        request.headers.set("Content-Type", contentType);
-      request.body = body;
+      if (contentType && !headers.has("Content-Type"))
+        headers.set("Content-Type", contentType);
     }
+    return new Request(requestInit.url.toString(), requestInit);
   }
-  async _parseBody(fetchResponse) {
+  createResponse(init) {
+    return new HttpResponse(init);
+  }
+  async parseBody(fetchResponse) {
     let body;
     const contentType = fetchResponse.headers.get("Content-Type") || "";
     if (typeIs.is(contentType, ["json", "application/*+json"])) {
@@ -311,17 +283,174 @@ var HttpRequestObservable = class extends Observable {
   }
 };
 
-// ../../build/client/esm/impl/collection-node.js
+// ../../build/client/esm/http/http-client-base.js
+import { ApiDocumentFactory } from "@opra/common";
+
+// ../../build/client/esm/http/http-collection-node.js
+import { toArrayDef } from "putil-varhelpers";
+import { OpraURL as OpraURL2 } from "@opra/common";
+
+// ../../build/client/esm/http/http-request-observable.js
+import { lastValueFrom, Observable as Observable2 } from "rxjs";
+import typeIs2 from "@browsery/type-is";
+import { OpraURL } from "@opra/common";
+
+// ../../build/client/esm/http/enums/http-observable-type.enum.js
+var HttpObserveType;
+(function(HttpObserveType2) {
+  HttpObserveType2["ResponseHeader"] = "response-header";
+  HttpObserveType2["Response"] = "response";
+  HttpObserveType2["Body"] = "body";
+  HttpObserveType2["Events"] = "events";
+})(HttpObserveType || (HttpObserveType = {}));
+
+// ../../build/client/esm/http/http-interceptor-handler.js
+var HttpInterceptorHandler = class {
+  static {
+    __name(this, "HttpInterceptorHandler");
+  }
+  constructor(interceptors, finalHandler) {
+    this.chain = interceptors.reduceRight((chainTailFn, interceptor) => (initialRequest, handler) => interceptor.intercept(initialRequest, {
+      handle: (downstreamRequest) => chainTailFn(downstreamRequest, handler)
+    }), chainEnd);
+    this.finalHandler = finalHandler;
+  }
+  handle(initialRequest) {
+    return this.chain(initialRequest, (req) => this.finalHandler.handle(req));
+  }
+};
+function chainEnd(req, handler) {
+  return handler(req);
+}
+__name(chainEnd, "chainEnd");
+
+// ../../build/client/esm/http/http-request-observable.js
+var HttpRequestObservable = class _HttpRequestObservable extends Observable2 {
+  static {
+    __name(this, "HttpRequestObservable");
+  }
+  constructor(backend, init) {
+    super((subscriber) => {
+      const observe = this[kContext].observe;
+      new HttpInterceptorHandler(backend.interceptors || [], this[kBackend]).handle(this[kContext]).subscribe({
+        next(event) {
+          if (observe === HttpObserveType.Events) {
+            subscriber.next(event);
+            return;
+          }
+          if (observe === HttpObserveType.ResponseHeader && event.type === HttpEventType.ResponseHeader) {
+            subscriber.next(event.response);
+            subscriber.complete();
+            return;
+          }
+          if (event.type === HttpEventType.Response) {
+            const { response } = event;
+            if (observe === HttpObserveType.Response) {
+              subscriber.next(response);
+              subscriber.complete();
+              return;
+            }
+            const isOpraResponse = typeIs2.is(event.response.contentType || "", ["application/opra+json"]);
+            if (response.status >= 400 && response.status < 600) {
+              subscriber.error(new ClientError({
+                message: response.status + " " + response.statusText,
+                status: response.status,
+                issues: isOpraResponse ? response.body.errors : void 0
+              }));
+              subscriber.complete();
+              return;
+            }
+            subscriber.next(event.response.body);
+            subscriber.complete();
+          }
+        },
+        error(error) {
+          subscriber.error(error);
+        },
+        complete() {
+          subscriber.complete();
+        }
+      });
+    });
+    Object.defineProperty(this, kBackend, {
+      enumerable: false,
+      value: backend
+    });
+    const url = new OpraURL(init?.url, backend.serviceUrl.toString());
+    Object.defineProperty(this, kContext, {
+      enumerable: false,
+      value: {
+        ...init,
+        observe: HttpObserveType.Body,
+        headers: new Headers(init?.headers),
+        url
+      }
+    });
+  }
+  clone() {
+    return new _HttpRequestObservable(this[kBackend], this[kContext]);
+  }
+  options(options) {
+    Object.assign(this[kContext], options);
+    return this;
+  }
+  header(arg0, value) {
+    const target = this[kContext].headers;
+    if (typeof arg0 === "object") {
+      const h = arg0 instanceof Headers ? arg0 : new Headers(arg0);
+      h.forEach((v, k) => {
+        if (k.toLowerCase() === "set-cookie") {
+          target.append(k, v);
+        } else
+          target.set(k, v);
+      });
+      return this;
+    }
+    if (value == null || value === "")
+      target.delete(arg0);
+    else
+      target.append(arg0, String(value));
+    return this;
+  }
+  param(arg0, value) {
+    const target = this[kContext].url.searchParams;
+    if (typeof arg0 === "object") {
+      const h = arg0 instanceof URLSearchParams ? arg0 : new URLSearchParams(arg0);
+      h.forEach((v, k) => target.set(k, v));
+      return this;
+    }
+    if (value == null)
+      target.delete(arg0);
+    else
+      target.set(arg0, String(value));
+    return this;
+  }
+  observe(observe) {
+    if (observe === this[kContext].observe)
+      return this;
+    const cloned = this.clone();
+    cloned[kContext].observe = observe || HttpObserveType.Body;
+    return cloned;
+  }
+  getBody() {
+    return lastValueFrom(this.observe(HttpObserveType.Body));
+  }
+  getResponse() {
+    return lastValueFrom(this.observe(HttpObserveType.Response));
+  }
+};
+
+// ../../build/client/esm/http/http-collection-node.js
 var HttpCollectionNode = class {
   static {
     __name(this, "HttpCollectionNode");
   }
-  constructor(client, path) {
-    this._client = client;
+  constructor(backend, path) {
+    this._backend = backend;
     this._path = path;
   }
   create(data, options) {
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "POST",
       url: this._path,
       body: data
@@ -337,15 +466,15 @@ var HttpCollectionNode = class {
   delete(id) {
     if (id == null || id === "")
       throw new TypeError(`'id' argument must have a value`);
-    const url = new OpraURL3();
+    const url = new OpraURL2();
     url.join({ resource: this._path, key: id });
-    return new HttpRequestObservable(this._client, {
+    return new HttpRequestObservable(this._backend, {
       method: "DELETE",
       url
     });
   }
   deleteMany(options) {
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "DELETE",
       url: this._path
     });
@@ -356,9 +485,9 @@ var HttpCollectionNode = class {
   get(id, options) {
     if (id == null || id === "")
       throw new TypeError(`'id' argument must have a value`);
-    const url = new OpraURL3();
+    const url = new OpraURL2();
     url.join({ resource: this._path, key: id });
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "GET",
       url
     });
@@ -371,7 +500,7 @@ var HttpCollectionNode = class {
     return observable;
   }
   findMany(options) {
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "GET",
       url: this._path
     });
@@ -398,9 +527,9 @@ var HttpCollectionNode = class {
   update(id, data, options) {
     if (id == null)
       throw new TypeError(`'id' argument must have a value`);
-    const url = new OpraURL3();
+    const url = new OpraURL2();
     url.join({ resource: this._path, key: id });
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "PATCH",
       url,
       body: data
@@ -414,7 +543,7 @@ var HttpCollectionNode = class {
     return observable;
   }
   updateMany(data, options) {
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "PATCH",
       url: this._path,
       body: data
@@ -425,38 +554,18 @@ var HttpCollectionNode = class {
   }
 };
 
-// ../../build/client/esm/impl/http-response.js
-var HttpResponse = class _HttpResponse {
-  static {
-    __name(this, "HttpResponse");
-  }
-  constructor(init) {
-    this.hasBody = false;
-    this.headers = init?.headers instanceof Headers ? init?.headers : new Headers(init?.headers);
-    this.status = init?.status || 200;
-    this.statusText = init?.statusText || "OK";
-    this.url = init?.url || null;
-    this.ok = this.status >= 200 && this.status < 300;
-    this.body = init?.body;
-    this.hasBody = init?.body != null || !!init?.hasBody;
-  }
-  clone(update) {
-    return new _HttpResponse({ ...this, ...update });
-  }
-};
-
-// ../../build/client/esm/impl/singleton-node.js
+// ../../build/client/esm/http/http-singleton-node.js
 import { toArrayDef as toArrayDef2 } from "putil-varhelpers";
 var HttpSingletonNode = class {
   static {
     __name(this, "HttpSingletonNode");
   }
-  constructor(client, path) {
-    this._client = client;
+  constructor(backend, path) {
+    this._backend = backend;
     this._path = path;
   }
   create(data, options) {
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "POST",
       url: this._path,
       body: data
@@ -470,13 +579,13 @@ var HttpSingletonNode = class {
     return observable;
   }
   delete() {
-    return new HttpRequestObservable(this._client, {
+    return new HttpRequestObservable(this._backend, {
       method: "DELETE",
       url: this._path
     });
   }
   get(options) {
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "GET",
       url: this._path
     });
@@ -489,7 +598,7 @@ var HttpSingletonNode = class {
     return observable;
   }
   update(data, options) {
-    const observable = new HttpRequestObservable(this._client, {
+    const observable = new HttpRequestObservable(this._backend, {
       method: "PATCH",
       url: this._path,
       body: data
@@ -504,54 +613,32 @@ var HttpSingletonNode = class {
   }
 };
 
-// ../../build/client/esm/client.js
-var OpraHttpClient = class {
+// ../../build/client/esm/http/http-client-base.js
+var HttpClientBase = class extends ClientBase {
   static {
-    __name(this, "OpraHttpClient");
+    __name(this, "HttpClientBase");
   }
-  constructor(serviceUrl, options) {
-    const context = {
-      serviceUrl,
-      requestInterceptors: [...options?.requestInterceptors || []],
-      responseInterceptors: [...options?.responseInterceptors || []],
-      api: options?.api,
-      defaults: {
-        ...options?.defaults,
-        headers: options?.defaults?.headers instanceof Headers ? options?.defaults?.headers : new Headers(options?.defaults?.headers),
-        params: options?.defaults?.params instanceof URLSearchParams ? options?.defaults?.params : new URLSearchParams(options?.defaults?.params)
-      },
-      fetch,
-      createResponse: (init) => new HttpResponse(init)
-    };
-    Object.defineProperty(this, kContext, {
-      enumerable: false,
-      value: context
-    });
+  constructor(backend) {
+    super(backend);
   }
   get serviceUrl() {
-    return this[kContext].serviceUrl;
-  }
-  get api() {
-    return this[kContext].api;
-  }
-  get defaults() {
-    return this[kContext].defaults;
+    return this[kBackend].serviceUrl;
   }
   async getMetadata() {
     let promise = this._metadataPromise;
     if (promise)
       return promise;
-    const controller = new HttpRequestObservable(this, {
+    const request = new HttpRequestObservable(this[kBackend], {
       method: "GET",
-      url: "",
-      headers: { "accept": "application/json" }
+      url: "/",
+      headers: new Headers({ "accept": "application/json" })
     });
-    this._metadataPromise = promise = controller.getBody();
+    this._metadataPromise = promise = request.getBody();
     return await promise.then(async (body) => {
       if (!body)
         throw new Error(`No response returned.`);
       const api = await ApiDocumentFactory.createDocument(body);
-      this[kContext].api = api;
+      this[kBackend].api = api;
       return api;
     }).catch((e) => {
       e.message = "Unable to fetch metadata from service url (" + this.serviceUrl + "). " + e.message;
@@ -559,13 +646,13 @@ var OpraHttpClient = class {
     }).finally(() => delete this._metadataPromise);
   }
   collection(path) {
-    return new HttpCollectionNode(this, path);
+    return new HttpCollectionNode(this[kBackend], path);
   }
   singleton(path) {
-    return new HttpSingletonNode(this, path);
+    return new HttpSingletonNode(this[kBackend], path);
   }
   action(path, params) {
-    const observable = new HttpRequestObservable(this, {
+    const observable = new HttpRequestObservable(this[kBackend], {
       method: "GET",
       url: path
     });
@@ -577,7 +664,20 @@ var OpraHttpClient = class {
   }
 };
 
-// ../../build/client/esm/impl/http-service-base.js
+// ../../build/client/esm/http/http-client.js
+var OpraHttpClient = class extends HttpClientBase {
+  static {
+    __name(this, "OpraHttpClient");
+  }
+  constructor(serviceUrl, options) {
+    super(new FetchBackend(serviceUrl, options));
+  }
+  get defaults() {
+    return this[kBackend].defaults;
+  }
+};
+
+// ../../build/client/esm/http/http-service-base.js
 var _a;
 var HttpServiceBase = class {
   static {
@@ -585,7 +685,7 @@ var HttpServiceBase = class {
   }
   constructor(client) {
     this[_a] = {
-      resource: {},
+      resources: {},
       node: null
     };
     this[kClient] = client;
@@ -593,16 +693,21 @@ var HttpServiceBase = class {
 };
 _a = kContext;
 export {
+  Backend,
+  ClientBase,
   ClientError,
+  FetchBackend,
+  HttpBackend,
+  HttpClientBase,
   HttpCollectionNode,
   HttpEventType,
   HttpObserveType,
-  HttpRequest,
   HttpRequestObservable,
   HttpResponse,
   HttpServiceBase,
   HttpSingletonNode,
   OpraHttpClient,
+  kBackend,
   kClient,
   kContext
 };