@opra/client 0.18.0 → 0.18.2

package/browser.js

@@ -0,0 +1,576 @@
+/****************************************
+* All rights reserved Panates® 2022-2023
+* http://www.panates.com
+*****************************************/
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// ../../build/client/esm/client-error.js
+var ClientError = class extends Error {
+  constructor(init, cause) {
+    super(init.message);
+    this.cause = cause;
+    this.issues = init.issues || [];
+    this.status = init.status;
+    if (cause) {
+      this.cause = cause;
+      if (cause.stack)
+        this.stack = cause.stack;
+    }
+  }
+};
+__name(ClientError, "ClientError");
+
+// ../../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, HttpHeaders as HttpHeaders3, HttpParams, isBlob, joinPath } from "@opra/common";
+
+// ../../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");
+
+// ../../build/client/esm/http/http-request-observable.js
+import { lastValueFrom, Observable } from "rxjs";
+import { uid } from "@opra/common";
+
+// ../../build/client/esm/http/http-request.js
+import { HttpHeaders, OpraURL } from "@opra/common";
+var directCopyProperties = [
+  "cache",
+  "credentials",
+  "destination",
+  "headers",
+  "integrity",
+  "keepalive",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy"
+];
+var HttpRequest = class {
+  constructor(init) {
+    this.cache = init?.cache || "default";
+    this.credentials = init?.credentials || "same-origin";
+    this.destination = init?.destination || "";
+    this.headers = new HttpHeaders(init?.headers);
+    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.urlInstance = new OpraURL(init?.url);
+    if (init?.params)
+      this.params.appendAll(init.params);
+  }
+  /** Returns the URL of request as a string. */
+  get url() {
+    return this.urlInstance.href;
+  }
+  set url(value) {
+    this.urlInstance.parse(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;
+  }
+  clone(...update) {
+    const out = new HttpRequest();
+    out.merge(this);
+    for (const upd of update) {
+      out.merge(upd);
+    }
+    return out;
+  }
+  merge(update) {
+    directCopyProperties.forEach((k) => {
+      if (update[k] != null)
+        this[k] = update[k];
+    });
+    if (update.headers) {
+      const h = update.headers instanceof HttpHeaders ? update.headers : new HttpHeaders(update.headers);
+      h.forEach((v, k) => {
+        if (k.toLowerCase() === "set-cookie") {
+          this.headers.append(k, v);
+        } else
+          this.headers.set(k, v);
+      });
+    }
+  }
+  inset(src) {
+    directCopyProperties.forEach((k) => {
+      if (this[k] == null && src[k] != null)
+        this[k] = src[k];
+    });
+    if (src.headers) {
+      const h = src.headers instanceof HttpHeaders ? src.headers : new HttpHeaders(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);
+      });
+    }
+  }
+};
+__name(HttpRequest, "HttpRequest");
+
+// ../../build/client/esm/http/http-request-observable.js
+var kRequest = Symbol("kRequest");
+var HttpRequestObservable = class extends Observable {
+  constructor(context, options) {
+    super((subscriber) => {
+      context.send(options?.observe || "body", this[kRequest]).subscribe(subscriber);
+    });
+    this[kHttpClientContext] = context;
+    this[kRequest] = new HttpRequest(options?.http);
+    this.contentId = uid(6);
+  }
+  header(name, value) {
+    this[kRequest].headers.append(name, value);
+    return this;
+  }
+  param(name, value) {
+    this[kRequest].params.append(name, value);
+    return this;
+  }
+  async fetch(observe) {
+    return lastValueFrom(this[kHttpClientContext].send(observe || "body", this[kRequest]));
+  }
+  with(cb) {
+    cb(this);
+    return this;
+  }
+};
+__name(HttpRequestObservable, "HttpRequestObservable");
+HttpRequestObservable.kContext = kHttpClientContext;
+HttpRequestObservable.kRequest = kRequest;
+
+// ../../build/client/esm/http/http-collection-node.js
+var HttpCollectionNode = class {
+  constructor(context) {
+    this[kHttpClientContext] = context;
+  }
+  create(data, options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "POST";
+    request.url = context.resourceName;
+    request.body = data;
+    if (options?.include)
+      request.params.set("$include", options.include);
+    if (options?.pick)
+      request.params.set("$pick", options.pick);
+    if (options?.omit)
+      request.params.set("$omit", options.omit);
+    return requestHost;
+  }
+  delete(id, options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "DELETE";
+    request.path.join({ resource: context.resourceName, key: id });
+    return requestHost;
+  }
+  deleteMany(options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "DELETE";
+    request.url = context.resourceName;
+    if (options?.filter)
+      request.params.set("$filter", options.filter);
+    return requestHost;
+  }
+  get(id, options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "GET";
+    request.path.join({ resource: context.resourceName, key: id });
+    if (options?.include)
+      request.params.set("$include", options.include);
+    if (options?.pick)
+      request.params.set("$pick", options.pick);
+    if (options?.omit)
+      request.params.set("$omit", options.omit);
+    return requestHost;
+  }
+  findMany(options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "GET";
+    request.url = context.resourceName;
+    if (options?.include)
+      request.params.set("$include", options.include);
+    if (options?.pick)
+      request.params.set("$pick", options.pick);
+    if (options?.omit)
+      request.params.set("$omit", options.omit);
+    if (options?.sort)
+      request.params.set("$sort", options.sort);
+    if (options?.filter)
+      request.params.set("$filter", options.filter);
+    if (options?.limit != null)
+      request.params.set("$limit", options.limit);
+    if (options?.skip != null)
+      request.params.set("$skip", options.skip);
+    if (options?.count != null)
+      request.params.set("$count", options.count);
+    if (options?.distinct != null)
+      request.params.set("$distinct", options.distinct);
+    return requestHost;
+  }
+  update(id, data, options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "PATCH";
+    request.path.join({ resource: context.resourceName, key: id });
+    request.body = data;
+    if (options?.include)
+      request.params.set("$include", options.include);
+    if (options?.pick)
+      request.params.set("$pick", options.pick);
+    if (options?.omit)
+      request.params.set("$omit", options.omit);
+    return requestHost;
+  }
+  updateMany(data, options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "PATCH";
+    request.url = context.resourceName;
+    request.body = data;
+    if (options?.filter)
+      request.params.set("$filter", options.filter);
+    return requestHost;
+  }
+};
+__name(HttpCollectionNode, "HttpCollectionNode");
+
+// ../../build/client/esm/http/http-response.js
+import { HttpHeaders as HttpHeaders2 } from "@opra/common";
+var HttpResponse = class {
+  constructor(init) {
+    this.hasBody = false;
+    this.headers = new HttpHeaders2(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.totalMatches = init?.totalMatches;
+  }
+  clone(update) {
+    return new HttpResponse({ ...this, ...update });
+  }
+};
+__name(HttpResponse, "HttpResponse");
+
+// ../../build/client/esm/http/http-singleton-node.js
+var HttpSingletonNode = class {
+  constructor(context) {
+    this[kHttpClientContext] = context;
+  }
+  create(data, options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "POST";
+    request.url = context.resourceName;
+    request.body = data;
+    if (options?.include)
+      request.params.set("$include", options.include);
+    if (options?.pick)
+      request.params.set("$pick", options.pick);
+    if (options?.omit)
+      request.params.set("$omit", options.omit);
+    return requestHost;
+  }
+  delete(options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "DELETE";
+    request.path.join({ resource: context.resourceName });
+    return requestHost;
+  }
+  get(options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "GET";
+    request.path.join({ resource: context.resourceName });
+    if (options?.include)
+      request.params.set("$include", options.include);
+    if (options?.pick)
+      request.params.set("$pick", options.pick);
+    if (options?.omit)
+      request.params.set("$omit", options.omit);
+    return requestHost;
+  }
+  update(data, options) {
+    const context = this[kHttpClientContext];
+    const requestHost = new HttpRequestObservable(context, options);
+    const request = requestHost[HttpRequestObservable.kRequest];
+    request.method = "PATCH";
+    request.path.join({ resource: context.resourceName });
+    request.body = data;
+    if (options?.include)
+      request.params.set("$include", options.include);
+    if (options?.pick)
+      request.params.set("$pick", options.pick);
+    if (options?.omit)
+      request.params.set("$omit", options.omit);
+    return requestHost;
+  }
+};
+__name(HttpSingletonNode, "HttpSingletonNode");
+
+// ../../build/client/esm/http/http-client.js
+var kAssets = Symbol("kAssets");
+var OpraHttpClient = class {
+  constructor(serviceUrl, options) {
+    Object.defineProperty(this, kAssets, {
+      enumerable: false,
+      value: {
+        serviceUrl,
+        api: options?.api,
+        requestInterceptors: options?.requestInterceptors || [],
+        responseInterceptors: options?.responseInterceptors || []
+      }
+    });
+    this.defaults = {
+      ...options?.defaults,
+      headers: options?.defaults?.headers instanceof HttpHeaders3 ? options?.defaults?.headers : new HttpHeaders3(options?.defaults?.headers),
+      params: options?.defaults?.params instanceof HttpParams ? options?.defaults?.params : new HttpParams(options?.defaults?.params)
+    };
+  }
+  get serviceUrl() {
+    return this[kAssets].serviceUrl;
+  }
+  async getMetadata() {
+    if (this[kAssets].api)
+      return this[kAssets].api;
+    let promise = this[kAssets].metadataPromise;
+    if (promise) {
+      return promise;
+    }
+    this[kAssets].metadataPromise = promise = lastValueFrom2(this._sendRequest("body", new HttpRequest({
+      method: "GET",
+      url: "$metadata",
+      headers: new HttpHeaders3({ "accept": "application/json" })
+    })));
+    return await promise.then(async (body) => {
+      const api = await DocumentFactory.createDocument(body);
+      this[kAssets].api = api;
+      return api;
+    }).catch((e) => {
+      e.message = "Unable to fetch metadata from " + 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,
+      resourceName,
+      send: (observe, request) => this._sendRequest(observe, request, ctx),
+      requestInterceptors: [
+        // Validate resource exists and is a collection resource
+        async () => {
+          const metadata = await this.getMetadata();
+          metadata.getCollection(ctx.resourceName);
+        }
+      ],
+      responseInterceptors: []
+    };
+    return new HttpCollectionNode(ctx);
+  }
+  singleton(resourceName) {
+    if (typeof resourceName === "function")
+      resourceName = resourceName.name;
+    const ctx = {
+      client: this,
+      resourceName,
+      send: (observe, request) => this._sendRequest(observe, request, ctx),
+      requestInterceptors: [
+        // Validate resource exists and is a singleton resource
+        async () => {
+          const metadata = await this.getMetadata();
+          metadata.getSingleton(ctx.resourceName);
+        }
+      ],
+      responseInterceptors: []
+    };
+    return new HttpSingletonNode(ctx);
+  }
+  _sendRequest(observe, request, ctx) {
+    return new Observable2((subscriber) => {
+      (async () => {
+        request.inset(this.defaults);
+        const url = request.url.includes("://") ? request.url : joinPath(this.serviceUrl, request.url);
+        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", 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", 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 === "events")
+          subscriber.next({ event: "sent", request });
+        const response = await this._fetch(url, { ...request, headers: request.headers.toObject() });
+        await this._handleResponse(observe, subscriber, request, response);
+      })().catch((error) => subscriber.error(error));
+    });
+  }
+  _fetch(url, init = {}) {
+    return fetch(url, init);
+  }
+  _createResponse(init) {
+    return new HttpResponse(init);
+  }
+  async _handleResponse(observe, subscriber, request, fetchResponse, ctx) {
+    const headers = new HttpHeaders3(fetchResponse.headers);
+    if (observe === "events") {
+      const response2 = this._createResponse({
+        url: fetchResponse.url,
+        headers,
+        status: fetchResponse.status,
+        statusText: fetchResponse.statusText,
+        hasBody: !!fetchResponse.body
+      });
+      subscriber.next({ event: "headers-received", request, response: response2 });
+    }
+    let body;
+    if (fetchResponse.body) {
+      if (JSON_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get("Content-Type") || "")) {
+        body = await fetchResponse.json();
+        if (typeof body === "string")
+          body = JSON.parse(body);
+      } else if (TEXT_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get("Content-Type") || ""))
+        body = await fetchResponse.text();
+      else if (FORMDATA_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get("Content-Type") || ""))
+        body = await fetchResponse.formData();
+      else {
+        const buf = await fetchResponse.arrayBuffer();
+        if (buf.byteLength)
+          body = buf;
+      }
+    }
+    if (observe === "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 (fetchResponse.headers.has(HttpHeaderCodes.X_Opra_Total_Matches))
+      responseInit.totalMatches = parseInt(fetchResponse.headers.get(HttpHeaderCodes.X_Opra_Total_Matches), 10);
+    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 === "body") {
+      subscriber.next(body);
+    } else {
+      if (observe === "events")
+        subscriber.next({ event: "response", request, response });
+      else
+        subscriber.next(response);
+    }
+    subscriber.complete();
+  }
+};
+__name(OpraHttpClient, "OpraHttpClient");
+OpraHttpClient.kAssets = kAssets;
+
+// ../../build/client/esm/http/http-service-base.js
+var HttpServiceBase = class {
+  constructor($client) {
+    this.$client = $client;
+  }
+};
+__name(HttpServiceBase, "HttpServiceBase");
+export {
+  ClientError,
+  HttpCollectionNode,
+  HttpRequest,
+  HttpRequestObservable,
+  HttpResponse,
+  HttpServiceBase,
+  HttpSingletonNode,
+  OpraHttpClient
+};

package/cjs/http/http-client.js

@@ -46,8 +46,11 @@ class OpraHttpClient {
             headers: new common_1.HttpHeaders({ 'accept': 'application/json' })
         })));
         return await promise
-            .then(body => common_1.DocumentFactory.createDocument(body))
-            .then(api => this[kAssets].api = api)
+            .then(async (body) => {
+            const api = await common_1.DocumentFactory.createDocument(body);
+            this[kAssets].api = api;
+            return api;
+        })
             .catch((e) => {
             e.message = 'Unable to fetch metadata from ' + this.serviceUrl + '. ' + e.message;
             throw e;

package/esm/http/http-client.js

@@ -43,8 +43,11 @@ export class OpraHttpClient {
             headers: new HttpHeaders({ 'accept': 'application/json' })
         })));
         return await promise
-            .then(body => DocumentFactory.createDocument(body))
-            .then(api => this[kAssets].api = api)
+            .then(async (body) => {
+            const api = await DocumentFactory.createDocument(body);
+            this[kAssets].api = api;
+            return api;
+        })
             .catch((e) => {
             e.message = 'Unable to fetch metadata from ' + this.serviceUrl + '. ' + e.message;
             throw e;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/client",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "Opra Client package",
   "author": "Panates",
   "license": "MIT",
@@ -12,7 +12,7 @@
   "scripts": {
     "compile": "tsc",
     "prebuild": "npm run check && npm run lint && npm run clean",
-    "build": "npm run build:cjs && npm run build:esm",
+    "build": "npm run build:cjs && npm run build:esm && npm run build:browser",
     "build:cjs": "tsc -b tsconfig-build-cjs.json",
     "build:esm": "tsc -b tsconfig-build-esm.json",
     "build:browser": "node esbuild.mjs",
@@ -33,13 +33,10 @@
   "types": "./types/index.d.ts",
   "typings": "./types/index.d.ts",
   "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
     ".": {
       "require": "./cjs/index.js",
-      "default": "./esm/index.js",
-      "browser": "./browser.js"
+      "browser": "./browser.js",
+      "default": "./esm/index.js"
     }
   },
   "dependencies": {
@@ -50,7 +47,7 @@
     "@browsery/i18next": "^0.5.0",
     "@browsery/stream": "^0.4.0",
     "@browsery/util": "^0.4.0",
-    "@opra/common": "^0.18.0",
+    "@opra/common": "^0.18.2",
     "accepts": "^1.3.8",
     "buffer": "^6.0.3",
     "cookie": "^0.5.0",
@@ -77,6 +74,7 @@
     "cjs/",
     "esm/",
     "types/",
+    "browser.js",
     "LICENSE",
     "README.md"
   ],