@opra/client 0.21.0 → 0.23.0

package/browser.js

@@ -6,6 +6,11 @@
 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 { isReadableStreamLike } from "rxjs/internal/util/isReadableStreamLike";
+import { DocumentFactory, isBlob, OpraURL as OpraURL2 } from "@opra/common";
+
 // ../../build/client/esm/client-error.js
 var ClientError = class extends Error {
   static {
@@ -24,22 +29,21 @@ var ClientError = class extends Error {
   }
 };
 
-// ../../build/client/esm/http/http-client.js
-import { lastValueFrom as lastValueFrom2, Observable as Observable2 } from "rxjs";
-import { isReadableStreamLike } from "rxjs/internal/util/isReadableStreamLike";
-import { DocumentFactory, HttpHeaderCodes, HttpParams, isBlob, joinPath } from "@opra/common";
+// ../../build/client/esm/collection-node.js
+import { toArrayDef } from "putil-varhelpers";
 
 // ../../build/client/esm/constants.js
 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 kHttpClientContext = Symbol("kContext");
+var kRequest = Symbol.for("kRequest");
+var kContext = Symbol.for("kContext");
 
-// ../../build/client/esm/http/http-request-observable.js
+// ../../build/client/esm/http-request-observable.js
 import { lastValueFrom, Observable } from "rxjs";
 import { uid } from "@opra/common";
 
-// ../../build/client/esm/http/http-request.js
+// ../../build/client/esm/http-request.js
 import { OpraURL } from "@opra/common";
 var directCopyProperties = [
   "cache",
@@ -72,24 +76,22 @@ var HttpRequest = class _HttpRequest {
     this.referrerPolicy = init?.referrerPolicy || "";
     this.signal = init?.signal || new AbortController().signal;
     this.body = init?.body;
-    this.urlInstance = new OpraURL(init?.url);
-    if (init?.params)
-      this.params.appendAll(init.params);
+    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.urlInstance.href;
+    return this.parsedUrl;
   }
   set url(value) {
-    this.urlInstance.parse(value);
+    this.parsedUrl = value;
   }
   /** Returns the searchParams of the URL as OpraURLSearchParams */
   get params() {
-    return this.urlInstance.searchParams;
-  }
-  /** Returns the path part of URL as OpraURLPath */
-  get path() {
-    return this.urlInstance.path;
+    return this.parsedUrl.searchParams;
   }
   clone(...update) {
     const out = new _HttpRequest();
@@ -131,17 +133,33 @@ var HttpRequest = class _HttpRequest {
   }
 };
 
-// ../../build/client/esm/http/http-request-observable.js
-var kRequest = Symbol("kRequest");
+// ../../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 || "body", this[kRequest]).subscribe(subscriber);
+      context.send(options?.observe || HttpObserveType.Body, this[kRequest]).subscribe(subscriber);
     });
-    this[kHttpClientContext] = context;
+    this[kContext] = context;
     this[kRequest] = new HttpRequest(options?.http);
     this.contentId = uid(6);
   }
@@ -158,126 +176,137 @@ var HttpRequestObservable = class extends Observable {
     return this;
   }
   async fetch(observe) {
-    return lastValueFrom(this[kHttpClientContext].send(observe || "body", this[kRequest]));
+    return lastValueFrom(this[kContext].send(observe || HttpObserveType.Body, this[kRequest]));
   }
   with(cb) {
     cb(this);
     return this;
   }
 };
-HttpRequestObservable.kContext = kHttpClientContext;
-HttpRequestObservable.kRequest = kRequest;
 
-// ../../build/client/esm/http/http-collection-node.js
+// ../../build/client/esm/collection-node.js
 var HttpCollectionNode = class {
   static {
     __name(this, "HttpCollectionNode");
   }
   constructor(context) {
-    this[kHttpClientContext] = context;
+    this[kContext] = context;
   }
   create(data, options) {
-    const context = this[kHttpClientContext];
+    const context = this[kContext];
+    context.operation = "create";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "POST";
-    request.url = context.resourceName;
+    request.url.resolve(context.resourceName);
     request.body = data;
     if (options?.include)
-      request.params.set("$include", options.include);
+      request.params.set("$include", toArrayDef(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", options.pick);
+      request.params.set("$pick", toArrayDef(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", options.omit);
+      request.params.set("$omit", toArrayDef(options.omit, []).join(","));
     return requestHost;
   }
   delete(id, options) {
-    const context = this[kHttpClientContext];
+    if (id == null)
+      throw new TypeError(`'id' argument must have a value`);
+    const context = this[kContext];
+    context.operation = "delete";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "DELETE";
-    request.path.join({ resource: context.resourceName, key: id });
+    request.url.join({ resource: context.resourceName, key: id });
     return requestHost;
   }
   deleteMany(options) {
-    const context = this[kHttpClientContext];
+    const context = this[kContext];
+    context.operation = "deleteMany";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "DELETE";
-    request.url = context.resourceName;
+    request.url.join(context.resourceName);
     if (options?.filter)
-      request.params.set("$filter", options.filter);
+      request.params.set("$filter", String(options.filter));
     return requestHost;
   }
   get(id, options) {
-    const context = this[kHttpClientContext];
+    if (id == null)
+      throw new TypeError(`'id' argument must have a value`);
+    const context = this[kContext];
+    context.operation = "get";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "GET";
-    request.path.join({ resource: context.resourceName, key: id });
+    request.url.join({ resource: context.resourceName, key: id });
     if (options?.include)
-      request.params.set("$include", options.include);
+      request.params.set("$include", toArrayDef(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", options.pick);
+      request.params.set("$pick", toArrayDef(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", options.omit);
+      request.params.set("$omit", toArrayDef(options.omit, []).join(","));
     return requestHost;
   }
   findMany(options) {
-    const context = this[kHttpClientContext];
+    const context = this[kContext];
+    context.operation = "findMany";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "GET";
-    request.url = context.resourceName;
+    request.url.join(context.resourceName);
     if (options?.include)
-      request.params.set("$include", options.include);
+      request.params.set("$include", toArrayDef(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", options.pick);
+      request.params.set("$pick", toArrayDef(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", options.omit);
+      request.params.set("$omit", toArrayDef(options.omit, []).join(","));
     if (options?.sort)
-      request.params.set("$sort", options.sort);
+      request.params.set("$sort", toArrayDef(options.sort, []).join(","));
     if (options?.filter)
-      request.params.set("$filter", options.filter);
+      request.params.set("$filter", String(options.filter));
     if (options?.limit != null)
-      request.params.set("$limit", options.limit);
+      request.params.set("$limit", String(options.limit));
     if (options?.skip != null)
-      request.params.set("$skip", options.skip);
+      request.params.set("$skip", String(options.skip));
     if (options?.count != null)
-      request.params.set("$count", options.count);
+      request.params.set("$count", String(options.count));
     if (options?.distinct != null)
-      request.params.set("$distinct", options.distinct);
+      request.params.set("$distinct", String(options.distinct));
     return requestHost;
   }
   update(id, data, options) {
-    const context = this[kHttpClientContext];
+    if (id == null)
+      throw new TypeError(`'id' argument must have a value`);
+    const context = this[kContext];
+    context.operation = "update";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "PATCH";
-    request.path.join({ resource: context.resourceName, key: id });
+    request.url.join({ resource: context.resourceName, key: id });
     request.body = data;
     if (options?.include)
-      request.params.set("$include", options.include);
+      request.params.set("$include", String(options.include));
     if (options?.pick)
-      request.params.set("$pick", options.pick);
+      request.params.set("$pick", String(options.pick));
     if (options?.omit)
-      request.params.set("$omit", options.omit);
+      request.params.set("$omit", String(options.omit));
     return requestHost;
   }
   updateMany(data, options) {
-    const context = this[kHttpClientContext];
+    const context = this[kContext];
+    context.operation = "updateMany";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "PATCH";
-    request.url = context.resourceName;
+    request.url.join(context.resourceName);
     request.body = data;
     if (options?.filter)
-      request.params.set("$filter", options.filter);
+      request.params.set("$filter", String(options.filter));
     return requestHost;
   }
 };
 
-// ../../build/client/esm/http/http-response.js
+// ../../build/client/esm/http-response.js
 var HttpResponse = class _HttpResponse {
   static {
     __name(this, "HttpResponse");
@@ -291,76 +320,81 @@ var HttpResponse = class _HttpResponse {
     this.ok = this.status >= 200 && this.status < 300;
     this.body = init?.body;
     this.hasBody = init?.body != null || !!init?.hasBody;
-    this.totalMatches = init?.totalMatches;
+    this.totalCount = init?.totalCount;
   }
   clone(update) {
     return new _HttpResponse({ ...this, ...update });
   }
 };
 
-// ../../build/client/esm/http/http-singleton-node.js
+// ../../build/client/esm/singleton-node.js
+import { toArrayDef as toArrayDef2 } from "putil-varhelpers";
 var HttpSingletonNode = class {
   static {
     __name(this, "HttpSingletonNode");
   }
   constructor(context) {
-    this[kHttpClientContext] = context;
+    this[kContext] = context;
   }
   create(data, options) {
-    const context = this[kHttpClientContext];
+    const context = this[kContext];
+    context.operation = "create";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "POST";
-    request.url = context.resourceName;
+    request.url.join(context.resourceName);
     request.body = data;
     if (options?.include)
-      request.params.set("$include", options.include);
+      request.params.set("$include", toArrayDef2(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", options.pick);
+      request.params.set("$pick", toArrayDef2(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", options.omit);
+      request.params.set("$omit", toArrayDef2(options.omit, []).join(","));
     return requestHost;
   }
   delete(options) {
-    const context = this[kHttpClientContext];
+    const context = this[kContext];
+    context.operation = "delete";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "DELETE";
-    request.path.join({ resource: context.resourceName });
+    request.url.join({ resource: context.resourceName });
     return requestHost;
   }
   get(options) {
-    const context = this[kHttpClientContext];
+    const context = this[kContext];
+    context.operation = "get";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "GET";
-    request.path.join({ resource: context.resourceName });
+    request.url.join({ resource: context.resourceName });
     if (options?.include)
-      request.params.set("$include", options.include);
+      request.params.set("$include", toArrayDef2(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", options.pick);
+      request.params.set("$pick", toArrayDef2(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", options.omit);
+      request.params.set("$omit", toArrayDef2(options.omit, []).join(","));
     return requestHost;
   }
   update(data, options) {
-    const context = this[kHttpClientContext];
+    const context = this[kContext];
+    context.operation = "update";
     const requestHost = new HttpRequestObservable(context, options);
-    const request = requestHost[HttpRequestObservable.kRequest];
+    const request = requestHost[kRequest];
     request.method = "PATCH";
-    request.path.join({ resource: context.resourceName });
+    request.url.join({ resource: context.resourceName });
     request.body = data;
     if (options?.include)
-      request.params.set("$include", options.include);
+      request.params.set("$include", toArrayDef2(options.include, []).join(","));
     if (options?.pick)
-      request.params.set("$pick", options.pick);
+      request.params.set("$pick", toArrayDef2(options.pick, []).join(","));
     if (options?.omit)
-      request.params.set("$omit", options.omit);
+      request.params.set("$omit", toArrayDef2(options.omit, []).join(","));
     return requestHost;
   }
 };
 
-// ../../build/client/esm/http/http-client.js
+// ../../build/client/esm/client.js
 var kAssets = Symbol("kAssets");
 var OpraHttpClient = class {
   static {
@@ -379,7 +413,7 @@ var OpraHttpClient = class {
     this.defaults = {
       ...options?.defaults,
       headers: options?.defaults?.headers instanceof Headers ? options?.defaults?.headers : new Headers(options?.defaults?.headers),
-      params: options?.defaults?.params instanceof HttpParams ? options?.defaults?.params : new HttpParams(options?.defaults?.params)
+      params: options?.defaults?.params instanceof URLSearchParams ? options?.defaults?.params : new URLSearchParams(options?.defaults?.params)
     };
   }
   get serviceUrl() {
@@ -392,7 +426,7 @@ var OpraHttpClient = class {
     if (promise) {
       return promise;
     }
-    this[kAssets].metadataPromise = promise = lastValueFrom2(this._sendRequest("body", new HttpRequest({
+    this[kAssets].metadataPromise = promise = lastValueFrom2(this._sendRequest("Singleton", "get", HttpObserveType.Body, new HttpRequest({
       method: "GET",
       url: "$metadata",
       headers: new Headers({ "accept": "application/json" })
@@ -402,7 +436,7 @@ var OpraHttpClient = class {
       this[kAssets].api = api;
       return api;
     }).catch((e) => {
-      e.message = "Unable to fetch metadata from " + this.serviceUrl + ". " + e.message;
+      e.message = "Unable to fetch metadata from service url (" + this.serviceUrl + "). " + e.message;
       throw e;
     }).finally(() => delete this[kAssets].metadataPromise);
   }
@@ -415,8 +449,10 @@ var OpraHttpClient = class {
       resourceName = resourceName.name;
     const ctx = {
       client: this,
+      resourceKind: "Collection",
+      operation: "",
       resourceName,
-      send: (observe, request) => this._sendRequest(observe, request, ctx),
+      send: (observe, request) => this._sendRequest("Collection", ctx.operation, observe, request, ctx),
       // requestInterceptors: [
       //   // Validate resource exists and is a collection resource
       //   async () => {
@@ -433,8 +469,10 @@ var OpraHttpClient = class {
       resourceName = resourceName.name;
     const ctx = {
       client: this,
+      resourceKind: "Singleton",
+      operation: "",
       resourceName,
-      send: (observe, request) => this._sendRequest(observe, request, ctx),
+      send: (observe, request) => this._sendRequest("Singleton", ctx.operation, observe, request, ctx),
       // requestInterceptors: [
       //   // Validate resource exists and is a singleton resource
       //   async () => {
@@ -446,11 +484,11 @@ var OpraHttpClient = class {
     };
     return new HttpSingletonNode(ctx);
   }
-  _sendRequest(observe, request, ctx) {
+  _sendRequest(resourceKind, operation, observe, request, ctx) {
     return new Observable2((subscriber) => {
       (async () => {
         request.inset(this.defaults);
-        const url = request.url.includes("://") ? request.url : joinPath(this.serviceUrl, request.url);
+        const url = new OpraURL2(request.url, this.serviceUrl);
         let body;
         if (request.body) {
           let contentType;
@@ -492,10 +530,14 @@ var OpraHttpClient = class {
             await interceptor(ctx, request);
           }
         }
-        if (observe === "events")
-          subscriber.next({ event: "sent", request });
-        const response = await this._fetch(url, request);
-        await this._handleResponse(observe, subscriber, request, response);
+        if (observe === HttpObserveType.Events)
+          subscriber.next({
+            observe,
+            request,
+            event: HttpEventType.Sent
+          });
+        const response = await this._fetch(url.toString(), request);
+        await this._handleResponse(resourceKind, operation, observe, subscriber, request, response, ctx);
       })().catch((error) => subscriber.error(error));
     });
   }
@@ -505,9 +547,9 @@ var OpraHttpClient = class {
   _createResponse(init) {
     return new HttpResponse(init);
   }
-  async _handleResponse(observe, subscriber, request, fetchResponse, ctx) {
+  async _handleResponse(resourceKind, operation, observe, subscriber, request, fetchResponse, ctx) {
     const headers = fetchResponse.headers;
-    if (observe === "events") {
+    if (observe === HttpObserveType.Events) {
       const response2 = this._createResponse({
         url: fetchResponse.url,
         headers,
@@ -515,14 +557,21 @@ var OpraHttpClient = class {
         statusText: fetchResponse.statusText,
         hasBody: !!fetchResponse.body
       });
-      subscriber.next({ event: "headers-received", request, response: response2 });
+      subscriber.next({
+        observe,
+        request,
+        event: HttpEventType.ResponseHeader,
+        response: response2
+      });
     }
     let body;
+    let totalCount;
     if (fetchResponse.body) {
       if (JSON_CONTENT_TYPE_PATTERN.test(headers.get("Content-Type") || "")) {
         body = await fetchResponse.json();
         if (typeof body === "string")
           body = JSON.parse(body);
+        totalCount = body.totalCount;
       } 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") || ""))
@@ -533,7 +582,7 @@ var OpraHttpClient = class {
           body = buf;
       }
     }
-    if (observe === "body" && fetchResponse.status >= 400 && fetchResponse.status < 600) {
+    if (observe === HttpObserveType.Body && fetchResponse.status >= 400 && fetchResponse.status < 600) {
       subscriber.error(new ClientError({
         message: fetchResponse.status + " " + fetchResponse.statusText,
         status: fetchResponse.status,
@@ -549,8 +598,8 @@ var OpraHttpClient = class {
       statusText: fetchResponse.statusText,
       body
     };
-    if (fetchResponse.headers.has(HttpHeaderCodes.X_Opra_Total_Matches))
-      responseInit.totalMatches = parseInt(fetchResponse.headers.get(HttpHeaderCodes.X_Opra_Total_Matches), 10);
+    if (totalCount != null)
+      responseInit.totalCount = totalCount;
     const response = this._createResponse(responseInit);
     if (ctx) {
       const responseInterceptors = [
@@ -561,11 +610,19 @@ var OpraHttpClient = class {
         await interceptor(ctx, observe, request);
       }
     }
-    if (observe === "body") {
-      subscriber.next(body);
+    if (observe === HttpObserveType.Body) {
+      if ((resourceKind === "Collection" || resourceKind === "Singleton") && (operation === "create" || operation === "get" || operation === "findMany" || operation === "update"))
+        subscriber.next(body.data);
+      else
+        subscriber.next(body);
     } else {
-      if (observe === "events")
-        subscriber.next({ event: "response", request, response });
+      if (observe === HttpObserveType.Events)
+        subscriber.next({
+          observe,
+          request,
+          event: HttpEventType.Response,
+          response
+        });
       else
         subscriber.next(response);
     }
@@ -574,7 +631,7 @@ var OpraHttpClient = class {
 };
 OpraHttpClient.kAssets = kAssets;
 
-// ../../build/client/esm/http/http-service-base.js
+// ../../build/client/esm/http-service-base.js
 var HttpServiceBase = class {
   static {
     __name(this, "HttpServiceBase");
@@ -586,6 +643,8 @@ var HttpServiceBase = class {
 export {
   ClientError,
   HttpCollectionNode,
+  HttpEventType,
+  HttpObserveType,
   HttpRequest,
   HttpRequestObservable,
   HttpResponse,