@opra/client 0.17.1 → 0.17.2

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

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

package/cjs/http/http-types.js

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

package/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./client-error.js"), exports);
+tslib_1.__exportStar(require("./http/http-client.js"), exports);
+tslib_1.__exportStar(require("./http/http-collection-node.js"), exports);
+tslib_1.__exportStar(require("./http/http-request.js"), exports);
+tslib_1.__exportStar(require("./http/http-request-observable.js"), exports);
+tslib_1.__exportStar(require("./http/http-response.js"), exports);
+tslib_1.__exportStar(require("./http/http-service-base.js"), exports);
+tslib_1.__exportStar(require("./http/http-singleton-node.js"), exports);
+tslib_1.__exportStar(require("./http/http-types.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/esm/client-error.js

@@ -0,0 +1,13 @@
+export class ClientError 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;
+        }
+    }
+}

package/esm/constants.js

@@ -0,0 +1,4 @@
+export const JSON_CONTENT_TYPE_PATTERN = /^application\/([\w-]+\+)?\bjson\b/i;
+export const TEXT_CONTENT_TYPE_PATTERN = /^text\/.*$/i;
+export const FORMDATA_CONTENT_TYPE_PATTERN = /^multipart\/\bform-data\b/i;
+export const kHttpClientContext = Symbol('kContext');

package/esm/http/batch-request.js

@@ -0,0 +1,90 @@
+"use strict";
+// import { BatchMultipart } from '@opra/common';
+// import { HttpRequestHost } from '../http-request-host.js';
+// import { HttpResponse } from '../http-response.js';
+// import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
+//
+// export class BatchRequest extends HttpRequestHost {
+//
+//   protected _results = new WeakMap<HttpRequestHost, { error?: Error, response?: HttpResponse }>();
+//   protected _listeners = new Set<((error: Error | undefined, response?: HttpResponse) => void)>();
+//
+//   constructor(
+//       protected _handler: HttpRequestHandler,
+//       readonly requests: HttpRequestHost[],
+//       public options: CommonHttpRequestOptions = {}
+//   ) {
+//     super(_handler, options);
+//
+//     requests.forEach(request => {
+//       // Overwrite the _execute method
+//       Object.defineProperty(request, '_execute', {
+//         writable: true,
+//         enumerable: false,
+//         configurable: true,
+//         value: () => {
+//           return new Promise((resolve, reject) => {
+//             const x = this._results.get(request);
+//             if (x) {
+//               if (x.error)
+//                 return reject(x.error);
+//               return resolve(x.response);
+//             }
+//             const callback = (error, response) => {
+//               this._listeners.delete(callback);
+//               if (error)
+//                 return reject(error);
+//               resolve(response);
+//             };
+//             this._listeners.add(callback);
+//           })
+//         }
+//       })
+//     });
+//   }
+//
+//   prepare(): RawHttpRequest {
+//     const batch = this._buildBatchMultipart(this);
+//     const headers = {
+//       'content-type': 'multipart/mixed;boundary=' + batch.boundary
+//     }
+//     return mergeRawHttpRequests({
+//           method: 'POST',
+//           path: '/$batch',
+//           headers,
+//           body: batch.stream()
+//         },
+//         this.options.http
+//     );
+//   }
+//
+//   protected _buildBatchMultipart(batch: BatchRequest): BatchMultipart {
+//     const multipart = new BatchMultipart();
+//
+//     for (const req of batch.requests) {
+//       const prepared = req.prepare();
+//
+//       if (req instanceof BatchRequest) {
+//         const subMultipart = this._buildBatchMultipart(req);
+//         multipart.addBatch(subMultipart);
+//         continue;
+//       }
+//
+//       multipart.addRequestPart({
+//         method: prepared.method,
+//         url: prepared.path,
+//         headers: prepared.headers,
+//         data: prepared.body
+//       });
+//     }
+//
+//     return multipart;
+//   }
+//
+//   protected async _execute(): Promise<HttpResponse> {
+//     const req = this.prepare();
+//     const resp = await this._handler(req) as HttpResponse;
+//     return resp;
+//   }
+//
+// }

package/esm/http/http-client.js

@@ -0,0 +1,228 @@
+import { lastValueFrom, Observable } from 'rxjs';
+import { isReadableStreamLike } from 'rxjs/internal/util/isReadableStreamLike';
+import { DocumentFactory, HttpHeaderCodes, HttpHeaders, HttpParams, isBlob, joinPath, } from '@opra/common';
+import { ClientError } from '../client-error.js';
+import { FORMDATA_CONTENT_TYPE_PATTERN, JSON_CONTENT_TYPE_PATTERN, TEXT_CONTENT_TYPE_PATTERN } from '../constants.js';
+import { HttpCollectionNode } from './http-collection-node.js';
+import { HttpRequest } from './http-request.js';
+import { HttpResponse } from './http-response.js';
+import { HttpSingletonNode } from './http-singleton-node.js';
+const kAssets = Symbol('kAssets');
+export class OpraHttpClient {
+    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 HttpHeaders
+                ? options?.defaults?.headers : new HttpHeaders(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 = lastValueFrom(this._sendRequest('body', new HttpRequest({
+            method: 'GET',
+            url: '$metadata',
+            headers: new HttpHeaders({ 'accept': 'application/json' })
+        })));
+        return await promise
+            .then(body => DocumentFactory.createDocument(body))
+            .then(api => this[kAssets].api = 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 name argument is a class, we extract name from the class
+        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 name argument is a class, we extract name from the class
+        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 Observable(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 HttpHeaders(fetchResponse.headers);
+        if (observe === 'events') {
+            const response = this._createResponse({
+                url: fetchResponse.url,
+                headers,
+                status: fetchResponse.status,
+                statusText: fetchResponse.statusText,
+                hasBody: !!fetchResponse.body
+            });
+            subscriber.next({ event: 'headers-received', request, response });
+        }
+        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();
+    }
+}
+OpraHttpClient.kAssets = kAssets;

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

@@ -0,0 +1,106 @@
+import { kHttpClientContext } from '../constants.js';
+import { HttpRequestObservable } from './http-request-observable.js';
+export class HttpCollectionNode {
+    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;
+    }
+}

package/esm/http/http-request-observable.js

@@ -0,0 +1,32 @@
+import { lastValueFrom, Observable } from 'rxjs';
+import { uid } from '@opra/common';
+import { kHttpClientContext } from '../constants.js';
+import { HttpRequest } from './http-request.js';
+const kRequest = Symbol('kRequest');
+export class HttpRequestObservable 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;
+    }
+}
+HttpRequestObservable.kContext = kHttpClientContext;
+HttpRequestObservable.kRequest = kRequest;

package/esm/http/http-request.js

@@ -0,0 +1,84 @@
+/// <reference lib="dom" />
+import { HttpHeaders, OpraURL } from '@opra/common';
+const directCopyProperties = ['cache', 'credentials', 'destination', 'headers', 'integrity',
+    'keepalive', 'mode', 'redirect', 'referrer', 'referrerPolicy'];
+export class HttpRequest {
+    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);
+            });
+        }
+    }
+}

package/esm/http/http-response.js

@@ -0,0 +1,20 @@
+import { HttpHeaders } from '@opra/common';
+export class HttpResponse {
+    constructor(init) {
+        /**
+         * Returns true if response has body to be received
+         */
+        this.hasBody = false;
+        this.headers = new HttpHeaders(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 });
+    }
+}

package/esm/http/http-service-base.js

@@ -0,0 +1,5 @@
+export class HttpServiceBase {
+    constructor($client) {
+        this.$client = $client;
+    }
+}