@opra/client 0.25.5 → 0.26.1

package/browser.js

@@ -7,9 +7,24 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // ../../build/client/esm/client.js
-import { lastValueFrom as lastValueFrom2, Observable as Observable2 } from "rxjs";
+import { ApiDocumentFactory } from "@opra/common";
+
+// ../../build/client/esm/constants.js
+var OPRA_JSON_CONTENT_TYPE_PATTERN = /^application\/\bopra\+json\b/i;
+var JSON_CONTENT_TYPE_PATTERN = /^application\/([\w-]+\+)?\bjson\b/i;
+var TEXT_CONTENT_TYPE_PATTERN = /^text\/.*$/i;
+var FORMDATA_CONTENT_TYPE_PATTERN = /^multipart\/\bform-data\b/i;
+var kClient = Symbol.for("kClient");
+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 { DocumentFactory, isBlob, OpraURL as OpraURL2 } from "@opra/common";
+import { isBlob, OpraURL as OpraURL2 } from "@opra/common";
 
 // ../../build/client/esm/client-error.js
 var ClientError = class extends Error {
@@ -29,36 +44,29 @@ var ClientError = class extends Error {
   }
 };
 
-// ../../build/client/esm/collection-node.js
-import { toArrayDef } from "putil-varhelpers";
-
-// ../../build/client/esm/constants.js
-var OPRA_JSON_CONTENT_TYPE_PATTERN = /^application\/\bopra\+json\b/i;
-var JSON_CONTENT_TYPE_PATTERN = /^application\/([\w-]+\+)?\bjson\b/i;
-var TEXT_CONTENT_TYPE_PATTERN = /^text\/.*$/i;
-var FORMDATA_CONTENT_TYPE_PATTERN = /^multipart\/\bform-data\b/i;
-var kRequest = Symbol.for("kRequest");
-var kContext = Symbol.for("kContext");
+// ../../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/http-request-observable.js
-import { lastValueFrom, Observable } from "rxjs";
-import { uid } from "@opra/common";
+// ../../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-request.js
+// ../../build/client/esm/impl/http-request.js
 import { OpraURL } from "@opra/common";
-var directCopyProperties = [
-  "cache",
-  "credentials",
-  "destination",
-  "headers",
-  "integrity",
-  "keepalive",
-  "mode",
-  "redirect",
-  "referrer",
-  "referrerPolicy"
-];
-var HttpRequest = class _HttpRequest {
+var HttpRequest = class {
   static {
     __name(this, "HttpRequest");
   }
@@ -66,7 +74,6 @@ var HttpRequest = class _HttpRequest {
     this.cache = init?.cache || "default";
     this.credentials = init?.credentials || "same-origin";
     this.destination = init?.destination || "";
-    this.headers = init?.headers instanceof Headers ? init.headers : new Headers(init?.headers);
     this.integrity = init?.integrity || "";
     this.keepalive = init?.keepalive ?? false;
     this.method = (init?.method || "GET").toUpperCase();
@@ -77,237 +84,350 @@ var HttpRequest = class _HttpRequest {
     this.referrerPolicy = init?.referrerPolicy || "";
     this.signal = init?.signal || new AbortController().signal;
     this.body = init?.body;
-    this.parsedUrl = new OpraURL(init?.url);
-    if (init?.params) {
-      const params = new URLSearchParams(init.params);
-      params.forEach((v, k) => this.params.set(k, v));
-    }
-  }
-  /** Returns the URL of request as a string. */
-  get url() {
-    return this.parsedUrl;
-  }
-  set url(value) {
-    this.parsedUrl = value;
+    this.url = init?.url instanceof OpraURL ? init.url : new OpraURL(init?.url);
+    this.headers = init?.headers instanceof Headers ? init.headers : new Headers(init?.headers);
   }
-  /** Returns the searchParams of the URL as OpraURLSearchParams */
-  get params() {
-    return this.parsedUrl.searchParams;
+};
+
+// ../../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 {
+  static {
+    __name(this, "HttpRequestObservable");
   }
-  clone(...update) {
-    const out = new _HttpRequest();
-    out.merge(this);
-    for (const upd of update) {
-      out.merge(upd);
-    }
-    return out;
+  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();
   }
-  merge(update) {
+  httpOptions(options) {
     directCopyProperties.forEach((k) => {
-      if (update[k] != null)
-        this[k] = update[k];
+      if (options[k] !== void 0)
+        this.request[k] = options[k];
     });
-    if (update.headers) {
-      const h = update.headers instanceof Headers ? update.headers : new Headers(update.headers);
+    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") {
-          this.headers.append(k, v);
+          headers.append(k, v);
         } else
-          this.headers.set(k, v);
+          headers.set(k, v);
       });
+      return this;
     }
+    if (value == null)
+      headers.delete(arg0);
+    else
+      headers.append(arg0, String(value));
+    return this;
   }
-  inset(src) {
-    directCopyProperties.forEach((k) => {
-      if (this[k] == null && src[k] != null)
-        this[k] = src[k];
-    });
-    if (src.headers) {
-      const h = src.headers instanceof Headers ? src.headers : new Headers(src.headers);
-      h.forEach((v, k) => {
-        if (k.toLowerCase() === "set-cookie") {
-          this.headers.append(k, v);
-        } else if (!this.headers.has(k))
-          this.headers.set(k, v);
-      });
+  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;
     }
-  }
-};
-
-// ../../build/client/esm/types.js
-var HttpObserveType;
-(function(HttpObserveType2) {
-  HttpObserveType2["Response"] = "response";
-  HttpObserveType2["Body"] = "body";
-  HttpObserveType2["Events"] = "events";
-})(HttpObserveType || (HttpObserveType = {}));
-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-request-observable.js
-var HttpRequestObservable = class extends Observable {
-  static {
-    __name(this, "HttpRequestObservable");
-  }
-  constructor(context, options) {
-    super((subscriber) => {
-      context.send(options?.observe || HttpObserveType.Body, this[kRequest]).subscribe(subscriber);
-    });
-    this[kContext] = context;
-    this[kRequest] = new HttpRequest(options?.http);
-    this.contentId = uid(6);
-  }
-  header(name, value) {
-    const headers = this[kRequest].headers;
-    if (Array.isArray(value))
-      value.forEach((v) => headers.append(name, String(v)));
+    if (value == null)
+      params.delete(arg0);
     else
-      headers.append(name, value);
+      params.set(arg0, String(value));
     return this;
   }
-  param(name, value) {
-    this[kRequest].params.append(name, value);
-    return this;
+  observe(observe) {
+    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 (observe === HttpObserveType.Body && event.event === HttpEventType.Response) {
+          subscriber.next(event.response.body);
+          subscriber.complete();
+          return;
+        }
+        if (event.event === HttpEventType.Response) {
+          subscriber.next(event.response);
+          subscriber.complete();
+        }
+      }, (error) => subscriber.error(error), () => subscriber.complete());
+    });
   }
-  async fetch(observe) {
-    return lastValueFrom(this[kContext].send(observe || HttpObserveType.Body, this[kRequest]));
+  toPromise() {
+    return this.getData();
   }
-  with(cb) {
-    cb(this);
-    return this;
+  getData() {
+    return lastValueFrom(this.observe(HttpObserveType.Body));
+  }
+  getResponse() {
+    return lastValueFrom(this.observe(HttpObserveType.Response));
+  }
+  _send() {
+    const request = this.request;
+    const clientContext = this[kClient][kContext];
+    return new Observable((subscriber) => {
+      (async () => {
+        this._prepareRequest();
+        for (const interceptor of clientContext.requestInterceptors) {
+          await interceptor(request);
+        }
+        subscriber.next({
+          request,
+          event: HttpEventType.Sent
+        });
+        const url = new OpraURL2(request.url, clientContext.serviceUrl);
+        const fetchResponse = await clientContext.fetch(url.toString(), request);
+        const headersResponse = clientContext.createResponse({
+          url: fetchResponse.url,
+          headers: fetchResponse.headers,
+          status: fetchResponse.status,
+          statusText: fetchResponse.statusText,
+          hasBody: !!fetchResponse.body
+        });
+        subscriber.next({
+          request,
+          event: HttpEventType.ResponseHeader,
+          response: headersResponse
+        });
+        const body = fetchResponse.body ? await this._parseBody(fetchResponse) : void 0;
+        if (fetchResponse.status >= 400 && fetchResponse.status <= 599) {
+          subscriber.error(new ClientError({
+            message: fetchResponse.status + " " + fetchResponse.statusText,
+            status: fetchResponse.status,
+            issues: body.errors
+          }));
+          subscriber.complete();
+          return;
+        }
+        const contentType = fetchResponse.headers.get("Content-Type") || "";
+        const responseInit = {
+          url: fetchResponse.url,
+          headers: fetchResponse.headers,
+          status: fetchResponse.status,
+          statusText: fetchResponse.statusText,
+          body
+        };
+        if (OPRA_JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
+          responseInit.totalCount = body?.totalCount;
+          responseInit.affected = body?.affected;
+        }
+        const response = clientContext.createResponse(responseInit);
+        for (const interceptor of clientContext.responseInterceptors) {
+          await interceptor(response);
+        }
+        subscriber.next({
+          request,
+          event: HttpEventType.Response,
+          response
+        });
+        subscriber.complete();
+      })().catch((error) => subscriber.error(error));
+    });
+  }
+  _prepareRequest() {
+    const request = this.request;
+    if (request.body) {
+      let 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)) {
+        contentType = "application/octet-stream";
+        body = request.body;
+        request.duplex = "half";
+      } else if (Buffer.isBuffer(request.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;
+      } else {
+        contentType = "application/json";
+        body = JSON.stringify(request.body);
+        request.headers.delete("Content-Size");
+        delete request.duplex;
+      }
+      if (!request.headers.has("Content-Type") && contentType)
+        request.headers.set("Content-Type", contentType);
+      request.body = body;
+    }
+  }
+  async _parseBody(fetchResponse) {
+    let body;
+    const contentType = fetchResponse.headers.get("Content-Type") || "";
+    if (JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
+      body = await fetchResponse.json();
+      if (typeof body === "string")
+        body = JSON.parse(body);
+    } else if (TEXT_CONTENT_TYPE_PATTERN.test(contentType))
+      body = await fetchResponse.text();
+    else if (FORMDATA_CONTENT_TYPE_PATTERN.test(contentType))
+      body = await fetchResponse.formData();
+    else {
+      const buf = await fetchResponse.arrayBuffer();
+      if (buf.byteLength)
+        body = buf;
+    }
+    return body;
   }
 };
 
-// ../../build/client/esm/collection-node.js
+// ../../build/client/esm/impl/collection-node.js
 var HttpCollectionNode = class {
   static {
     __name(this, "HttpCollectionNode");
   }
-  constructor(context) {
-    this[kContext] = context;
+  constructor(client, path) {
+    this._client = client;
+    this._path = path;
   }
   create(data, options) {
-    const context = this[kContext];
-    context.endpoint = "create";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "POST";
-    request.url.resolve(context.resource);
-    request.body = data;
+    const observable = new HttpRequestObservable(this._client, {
+      method: "POST",
+      url: this._path,
+      body: data
+    });
     if (options?.include)
-      request.params.set("$include", toArrayDef(options.include, []).join(","));
+      observable.param("include", toArrayDef(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", toArrayDef(options.pick, []).join(","));
+      observable.param("pick", toArrayDef(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", toArrayDef(options.omit, []).join(","));
-    return requestHost;
+      observable.param("omit", toArrayDef(options.omit, []).join(","));
+    return observable;
   }
-  delete(id, options) {
-    if (id == null)
+  delete(id) {
+    if (id == null || id === "")
       throw new TypeError(`'id' argument must have a value`);
-    const context = this[kContext];
-    context.endpoint = "delete";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "DELETE";
-    request.url.join({ resource: context.resource, key: id });
-    return requestHost;
+    const url = new OpraURL3();
+    url.join({ resource: this._path, key: id });
+    return new HttpRequestObservable(this._client, {
+      method: "DELETE",
+      url
+    });
   }
   deleteMany(options) {
-    const context = this[kContext];
-    context.endpoint = "deleteMany";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "DELETE";
-    request.url.join(context.resource);
+    const observable = new HttpRequestObservable(this._client, {
+      method: "DELETE",
+      url: this._path
+    });
     if (options?.filter)
-      request.params.set("$filter", String(options.filter));
-    return requestHost;
+      observable.param("filter", String(options.filter));
+    return observable;
   }
   get(id, options) {
-    if (id == null)
+    if (id == null || id === "")
       throw new TypeError(`'id' argument must have a value`);
-    const context = this[kContext];
-    context.endpoint = "get";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "GET";
-    request.url.join({ resource: context.resource, key: id });
+    const url = new OpraURL3();
+    url.join({ resource: this._path, key: id });
+    const observable = new HttpRequestObservable(this._client, {
+      method: "GET",
+      url
+    });
     if (options?.include)
-      request.params.set("$include", toArrayDef(options.include, []).join(","));
+      observable.param("include", toArrayDef(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", toArrayDef(options.pick, []).join(","));
+      observable.param("pick", toArrayDef(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", toArrayDef(options.omit, []).join(","));
-    return requestHost;
+      observable.param("omit", toArrayDef(options.omit, []).join(","));
+    return observable;
   }
   findMany(options) {
-    const context = this[kContext];
-    context.endpoint = "findMany";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "GET";
-    request.url.join(context.resource);
+    const observable = new HttpRequestObservable(this._client, {
+      method: "GET",
+      url: this._path
+    });
     if (options?.include)
-      request.params.set("$include", toArrayDef(options.include, []).join(","));
+      observable.param("include", toArrayDef(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", toArrayDef(options.pick, []).join(","));
+      observable.param("pick", toArrayDef(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", toArrayDef(options.omit, []).join(","));
+      observable.param("omit", toArrayDef(options.omit, []).join(","));
     if (options?.sort)
-      request.params.set("$sort", toArrayDef(options.sort, []).join(","));
+      observable.param("sort", toArrayDef(options.sort, []).join(","));
     if (options?.filter)
-      request.params.set("$filter", String(options.filter));
+      observable.param("filter", String(options.filter));
     if (options?.limit != null)
-      request.params.set("$limit", String(options.limit));
+      observable.param("limit", String(options.limit));
     if (options?.skip != null)
-      request.params.set("$skip", String(options.skip));
+      observable.param("skip", String(options.skip));
     if (options?.count != null)
-      request.params.set("$count", String(options.count));
+      observable.param("count", String(options.count));
     if (options?.distinct != null)
-      request.params.set("$distinct", String(options.distinct));
-    return requestHost;
+      observable.param("distinct", String(options.distinct));
+    return observable;
   }
   update(id, data, options) {
     if (id == null)
       throw new TypeError(`'id' argument must have a value`);
-    const context = this[kContext];
-    context.endpoint = "update";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "PATCH";
-    request.url.join({ resource: context.resource, key: id });
-    request.body = data;
+    const url = new OpraURL3();
+    url.join({ resource: this._path, key: id });
+    const observable = new HttpRequestObservable(this._client, {
+      method: "PATCH",
+      url,
+      body: data
+    });
     if (options?.include)
-      request.params.set("$include", String(options.include));
+      observable.param("include", toArrayDef(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", String(options.pick));
+      observable.param("pick", toArrayDef(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", String(options.omit));
-    return requestHost;
+      observable.param("omit", toArrayDef(options.omit, []).join(","));
+    return observable;
   }
   updateMany(data, options) {
-    const context = this[kContext];
-    context.endpoint = "updateMany";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "PATCH";
-    request.url.join(context.resource);
-    request.body = data;
+    const observable = new HttpRequestObservable(this._client, {
+      method: "PATCH",
+      url: this._path,
+      body: data
+    });
     if (options?.filter)
-      request.params.set("$filter", String(options.filter));
-    return requestHost;
+      observable.param("filter", String(options.filter));
+    return observable;
   }
 };
 
-// ../../build/client/esm/http-response.js
+// ../../build/client/esm/impl/http-response.js
 var HttpResponse = class _HttpResponse {
   static {
     __name(this, "HttpResponse");
@@ -328,328 +448,153 @@ var HttpResponse = class _HttpResponse {
   }
 };
 
-// ../../build/client/esm/singleton-node.js
+// ../../build/client/esm/impl/singleton-node.js
 import { toArrayDef as toArrayDef2 } from "putil-varhelpers";
 var HttpSingletonNode = class {
   static {
     __name(this, "HttpSingletonNode");
   }
-  constructor(context) {
-    this[kContext] = context;
+  constructor(client, path) {
+    this._client = client;
+    this._path = path;
   }
   create(data, options) {
-    const context = this[kContext];
-    context.endpoint = "create";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "POST";
-    request.url.join(context.resource);
-    request.body = data;
+    const observable = new HttpRequestObservable(this._client, {
+      method: "POST",
+      url: this._path,
+      body: data
+    });
     if (options?.include)
-      request.params.set("$include", toArrayDef2(options.include, []).join(","));
+      observable.param("include", toArrayDef2(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", toArrayDef2(options.pick, []).join(","));
+      observable.param("pick", toArrayDef2(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", toArrayDef2(options.omit, []).join(","));
-    return requestHost;
-  }
-  delete(options) {
-    const context = this[kContext];
-    context.endpoint = "delete";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "DELETE";
-    request.url.join({ resource: context.resource });
-    return requestHost;
+      observable.param("omit", toArrayDef2(options.omit, []).join(","));
+    return observable;
+  }
+  delete() {
+    return new HttpRequestObservable(this._client, {
+      method: "DELETE",
+      url: this._path
+    });
   }
   get(options) {
-    const context = this[kContext];
-    context.endpoint = "get";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "GET";
-    request.url.join({ resource: context.resource });
+    const observable = new HttpRequestObservable(this._client, {
+      method: "GET",
+      url: this._path
+    });
     if (options?.include)
-      request.params.set("$include", toArrayDef2(options.include, []).join(","));
+      observable.param("include", toArrayDef2(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", toArrayDef2(options.pick, []).join(","));
+      observable.param("pick", toArrayDef2(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", toArrayDef2(options.omit, []).join(","));
-    return requestHost;
+      observable.param("omit", toArrayDef2(options.omit, []).join(","));
+    return observable;
   }
   update(data, options) {
-    const context = this[kContext];
-    context.endpoint = "update";
-    const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[kRequest];
-    request.method = "PATCH";
-    request.url.join({ resource: context.resource });
-    request.body = data;
+    const observable = new HttpRequestObservable(this._client, {
+      method: "PATCH",
+      url: this._path,
+      body: data
+    });
     if (options?.include)
-      request.params.set("$include", toArrayDef2(options.include, []).join(","));
+      observable.param("include", toArrayDef2(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", toArrayDef2(options.pick, []).join(","));
+      observable.param("pick", toArrayDef2(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", toArrayDef2(options.omit, []).join(","));
-    return requestHost;
+      observable.param("omit", toArrayDef2(options.omit, []).join(","));
+    return observable;
   }
 };
 
 // ../../build/client/esm/client.js
-var kAssets = Symbol("kAssets");
 var OpraHttpClient = class {
   static {
     __name(this, "OpraHttpClient");
   }
   constructor(serviceUrl, options) {
-    Object.defineProperty(this, kAssets, {
+    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: {
-        serviceUrl,
-        api: options?.api,
-        requestInterceptors: options?.requestInterceptors || [],
-        responseInterceptors: options?.responseInterceptors || []
-      }
+      value: context
     });
-    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)
-    };
   }
   get serviceUrl() {
-    return this[kAssets].serviceUrl;
+    return this[kContext].serviceUrl;
+  }
+  get api() {
+    return this[kContext].api;
+  }
+  get defaults() {
+    return this[kContext].defaults;
   }
   async getMetadata() {
-    if (this[kAssets].api)
-      return this[kAssets].api;
-    let promise = this[kAssets].metadataPromise;
-    if (promise) {
+    let promise = this._metadataPromise;
+    if (promise)
       return promise;
-    }
-    this[kAssets].metadataPromise = promise = lastValueFrom2(this._sendRequest(HttpObserveType.Body, new HttpRequest({
+    const controller = new HttpRequestObservable(this, {
       method: "GET",
       url: "",
-      headers: new Headers({ "accept": "application/json" })
-    })));
+      headers: { "accept": "application/json" }
+    });
+    this._metadataPromise = promise = controller.getData();
     return await promise.then(async (body) => {
       if (!body)
         throw new Error(`No response returned.`);
-      const api = await DocumentFactory.createDocument(body);
-      this[kAssets].api = api;
+      const api = await ApiDocumentFactory.createDocument(body);
+      this[kContext].api = api;
       return api;
     }).catch((e) => {
       e.message = "Unable to fetch metadata from service url (" + this.serviceUrl + "). " + e.message;
       throw e;
-    }).finally(() => delete this[kAssets].metadataPromise);
-  }
-  // batch(requests: HttpRequestHost<any>[]): BatchRequest {
-  // this._assertMetadata();
-  // return new BatchRequest(request => this._sendRequest('response', request, requests);
-  // }
-  collection(resourceName) {
-    if (typeof resourceName === "function")
-      resourceName = resourceName.name;
-    const ctx = {
-      client: this,
-      sourceKind: "Collection",
-      endpoint: "",
-      resource: resourceName,
-      send: (observe, request) => this._sendRequest(observe, request, "Collection", ctx.endpoint, ctx),
-      // requestInterceptors: [
-      //   // Validate resource exists and is a collection resource
-      //   async () => {
-      //     const metadata = await this.getMetadata();
-      //     metadata.getCollection(ctx.sourceName);
-      //   }
-      // ],
-      responseInterceptors: []
-    };
-    return new HttpCollectionNode(ctx);
-  }
-  singleton(sourceName) {
-    if (typeof sourceName === "function")
-      sourceName = sourceName.name;
-    const ctx = {
-      client: this,
-      sourceKind: "Singleton",
-      endpoint: "",
-      resource: sourceName,
-      send: (observe, request) => this._sendRequest(observe, request, "Singleton", ctx.endpoint, ctx),
-      // requestInterceptors: [
-      //   // Validate resource exists and is a singleton resource
-      //   async () => {
-      //     const metadata = await this.getMetadata();
-      //     metadata.getSingleton(ctx.sourceName);
-      //   }
-      // ],
-      responseInterceptors: []
-    };
-    return new HttpSingletonNode(ctx);
+    }).finally(() => delete this._metadataPromise);
   }
-  _sendRequest(observe, request, sourceKind, endpoint, ctx) {
-    return new Observable2((subscriber) => {
-      (async () => {
-        request.inset(this.defaults);
-        const url = new OpraURL2(request.url, this.serviceUrl);
-        let body;
-        if (request.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)) {
-            contentType = "application/octet-stream";
-            body = request.body;
-            request.duplex = "half";
-          } else if (Buffer.isBuffer(request.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;
-          } else {
-            contentType = "application/json";
-            body = JSON.stringify(request.body);
-            request.headers.delete("Content-Size");
-            delete request.duplex;
-          }
-          if (!request.headers.has("Content-Type") && contentType)
-            request.headers.set("Content-Type", contentType);
-          request.body = body;
-        }
-        if (ctx) {
-          const requestInterceptors = [
-            ...this[kAssets].requestInterceptors,
-            ...ctx.requestInterceptors || []
-          ];
-          for (const interceptor of requestInterceptors) {
-            await interceptor(ctx, request);
-          }
-        }
-        if (observe === HttpObserveType.Events)
-          subscriber.next({
-            observe,
-            request,
-            event: HttpEventType.Sent
-          });
-        const response = await this._fetch(url.toString(), request);
-        await this._handleResponse(observe, subscriber, request, response, sourceKind, endpoint, ctx);
-      })().catch((error) => subscriber.error(error));
-    });
+  collection(path) {
+    return new HttpCollectionNode(this, path);
   }
-  _fetch(url, init = {}) {
-    return fetch(url, init);
-  }
-  _createResponse(init) {
-    return new HttpResponse(init);
-  }
-  async _handleResponse(observe, subscriber, request, fetchResponse, sourceKind, endpoint, ctx) {
-    const headers = fetchResponse.headers;
-    if (observe === HttpObserveType.Events) {
-      const response2 = this._createResponse({
-        url: fetchResponse.url,
-        headers,
-        status: fetchResponse.status,
-        statusText: fetchResponse.statusText,
-        hasBody: !!fetchResponse.body
-      });
-      subscriber.next({
-        observe,
-        request,
-        event: HttpEventType.ResponseHeader,
-        response: response2
-      });
-    }
-    let body;
-    let totalCount;
-    let affected;
-    const contentType = headers.get("Content-Type") || "";
-    if (fetchResponse.body) {
-      if (JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
-        body = await fetchResponse.json();
-        if (typeof body === "string")
-          body = JSON.parse(body);
-        if (OPRA_JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
-          totalCount = body.totalCount;
-          affected = body.affected;
-        }
-      } else if (TEXT_CONTENT_TYPE_PATTERN.test(headers.get("Content-Type") || ""))
-        body = await fetchResponse.text();
-      else if (FORMDATA_CONTENT_TYPE_PATTERN.test(headers.get("Content-Type") || ""))
-        body = await fetchResponse.formData();
-      else {
-        const buf = await fetchResponse.arrayBuffer();
-        if (buf.byteLength)
-          body = buf;
-      }
-    }
-    if (observe === HttpObserveType.Body && fetchResponse.status >= 400 && fetchResponse.status < 600) {
-      subscriber.error(new ClientError({
-        message: fetchResponse.status + " " + fetchResponse.statusText,
-        status: fetchResponse.status,
-        issues: body?.errors
-      }));
-      subscriber.complete();
-      return;
-    }
-    const responseInit = {
-      url: fetchResponse.url,
-      headers,
-      status: fetchResponse.status,
-      statusText: fetchResponse.statusText,
-      body
-    };
-    if (totalCount != null)
-      responseInit.totalCount = totalCount;
-    if (affected != null)
-      responseInit.affected = affected;
-    const response = this._createResponse(responseInit);
-    if (ctx) {
-      const responseInterceptors = [
-        ...this[kAssets].responseInterceptors,
-        ...ctx.responseInterceptors || []
-      ];
-      for (const interceptor of responseInterceptors) {
-        await interceptor(ctx, observe, request);
-      }
-    }
-    if (observe === HttpObserveType.Body) {
-      if (OPRA_JSON_CONTENT_TYPE_PATTERN.test(contentType))
-        subscriber.next(body.data);
-      else
-        subscriber.next(body);
-    } else {
-      if (observe === HttpObserveType.Events)
-        subscriber.next({
-          observe,
-          request,
-          event: HttpEventType.Response,
-          response
-        });
-      else
-        subscriber.next(response);
+  singleton(path) {
+    return new HttpSingletonNode(this, path);
+  }
+  action(path, params) {
+    const observable = new HttpRequestObservable(this, {
+      method: "GET",
+      url: path
+    });
+    if (params) {
+      Object.keys(params).forEach((k) => params[k] = String(params[k]));
+      observable.param(params);
     }
-    subscriber.complete();
+    return observable;
   }
 };
-OpraHttpClient.kAssets = kAssets;
 
-// ../../build/client/esm/http-service-base.js
+// ../../build/client/esm/impl/http-service-base.js
+var _a;
 var HttpServiceBase = class {
   static {
     __name(this, "HttpServiceBase");
   }
-  constructor($client) {
-    this.$client = $client;
+  constructor(client) {
+    this[_a] = {
+      resource: {},
+      node: null
+    };
+    this[kClient] = client;
   }
 };
+_a = kContext;
 export {
   ClientError,
   HttpCollectionNode,
@@ -660,5 +605,7 @@ export {
   HttpResponse,
   HttpServiceBase,
   HttpSingletonNode,
-  OpraHttpClient
+  OpraHttpClient,
+  kClient,
+  kContext
 };