@opra/client 0.27.0 → 0.28.0

package/cjs/constants.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.kContext = exports.kClient = void 0;
+exports.kContext = exports.kBackend = exports.kClient = void 0;
 exports.kClient = Symbol.for('kClient');
+exports.kBackend = Symbol.for('kBackend');
 exports.kContext = Symbol.for('kContext');

package/cjs/core/backend.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Backend = void 0;
+class Backend {
+    constructor(options) {
+        this.api = options?.api;
+    }
+}
+exports.Backend = Backend;

package/cjs/core/client-base.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientBase = void 0;
+const constants_js_1 = require("../constants.js");
+/**
+ *
+ * @class ClientBase
+ * @abstract
+ */
+class ClientBase {
+    constructor(backend) {
+        Object.defineProperty(this, constants_js_1.kBackend, {
+            enumerable: false,
+            value: backend
+        });
+    }
+}
+exports.ClientBase = ClientBase;

package/cjs/http/fetch-backend.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchBackend = void 0;
+const tslib_1 = require("tslib");
+// /// <reference lib="dom" />
+const rxjs_1 = require("rxjs");
+const isReadableStreamLike_1 = require("rxjs/internal/util/isReadableStreamLike");
+const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
+const common_1 = require("@opra/common");
+const http_backend_js_1 = require("./http-backend.js");
+const http_response_js_1 = require("./http-response.js");
+const http_event_js_1 = require("./interfaces/http-event.js");
+/**
+ *
+ * @class FetchBackend
+ */
+class FetchBackend extends http_backend_js_1.HttpBackend {
+    constructor(serviceUrl, options) {
+        super(serviceUrl, options);
+        // Create deduped interceptor array
+        this.interceptors = Array.from(new Set([...(options?.interceptors || [])]));
+        this.defaults = {
+            ...options?.defaults,
+            headers: options?.defaults?.headers instanceof Headers
+                ? options?.defaults?.headers : new Headers(options?.defaults?.headers),
+            params: options?.defaults?.params instanceof URLSearchParams
+                ? options?.defaults?.params : new URLSearchParams(options?.defaults?.params)
+        };
+    }
+    handle(init) {
+        return new rxjs_1.Observable((subscriber) => {
+            (async () => {
+                let request = this.prepareRequest(init);
+                if (request.body && init.reportProgress) {
+                    const stream = request.body;
+                    const contentLength = request.headers.get('content-length') || '0';
+                    const total = parseInt(contentLength, 10) || 0;
+                    let loaded = 0;
+                    const progressTrackingStream = new TransformStream({
+                        transform(chunk, controller) {
+                            controller.enqueue(chunk);
+                            loaded += chunk.byteLength;
+                            // Emit 'UploadProgress' event
+                            subscriber.next({
+                                type: http_event_js_1.HttpEventType.UploadProgress,
+                                request,
+                                total,
+                                loaded
+                            });
+                        }
+                    });
+                    request = new Request(request.url, {
+                        cache: request.cache,
+                        credentials: request.credentials,
+                        headers: request.headers,
+                        integrity: request.integrity,
+                        keepalive: request.keepalive,
+                        method: request.method,
+                        mode: request.mode,
+                        redirect: request.redirect,
+                        referrer: request.referrer,
+                        referrerPolicy: request.referrerPolicy,
+                        signal: request.signal,
+                        body: stream.pipeThrough(progressTrackingStream),
+                        window: init.window,
+                        ...{
+                            // undici library requires
+                            duplex: 'half'
+                        },
+                    });
+                }
+                // Send request
+                const fetchPromise = this.send(request);
+                // Emit 'Sent' event
+                subscriber.next({
+                    request,
+                    type: http_event_js_1.HttpEventType.Sent,
+                });
+                const fetchResponse = await fetchPromise;
+                // Emit 'ResponseHeader' event
+                const headersResponse = this.createResponse({
+                    url: fetchResponse.url,
+                    headers: fetchResponse.headers,
+                    status: fetchResponse.status,
+                    statusText: fetchResponse.statusText,
+                    hasBody: !!fetchResponse.body
+                });
+                subscriber.next({
+                    request,
+                    type: http_event_js_1.HttpEventType.ResponseHeader,
+                    response: headersResponse
+                });
+                // Parse body
+                let body;
+                if (fetchResponse.body) {
+                    if (init.reportProgress) {
+                        const fetchBody = fetchResponse.body;
+                        const contentLength = fetchResponse.headers.get('content-length') || '0';
+                        const total = parseInt(contentLength, 10) || 0;
+                        let loaded = 0;
+                        const res = new Response(new ReadableStream({
+                            async start(controller) {
+                                const reader = fetchBody.getReader();
+                                for (;;) {
+                                    const { done, value } = await reader.read();
+                                    if (done)
+                                        break;
+                                    loaded += value.byteLength;
+                                    controller.enqueue(value);
+                                    // Emit 'DownloadProgress' event
+                                    subscriber.next({
+                                        type: http_event_js_1.HttpEventType.DownloadProgress,
+                                        request,
+                                        total,
+                                        loaded
+                                    });
+                                }
+                                controller.close();
+                            },
+                        }));
+                        body = await this.parseBody(res);
+                    }
+                    else {
+                        body = await this.parseBody(fetchResponse);
+                    }
+                }
+                const response = this.createResponse({
+                    url: fetchResponse.url,
+                    headers: fetchResponse.headers,
+                    status: fetchResponse.status,
+                    statusText: fetchResponse.statusText,
+                    body,
+                });
+                // Emit 'Response' event
+                subscriber.next({
+                    request,
+                    type: http_event_js_1.HttpEventType.Response,
+                    response
+                });
+                subscriber.complete();
+            })().catch(error => subscriber.error(error));
+        });
+    }
+    send(request) {
+        return fetch(request);
+    }
+    prepareRequest(init) {
+        const headers = init.headers || new Headers();
+        const requestInit = {
+            ...init,
+            headers
+        };
+        const body = requestInit.body;
+        if (body) {
+            let contentType;
+            if (typeof body === 'string' || typeof body === 'number' || typeof body === 'boolean') {
+                contentType = 'text/plain; charset="UTF-8"';
+                requestInit.body = new Blob([String(body)], { type: contentType });
+                headers.set('Content-Length', String(requestInit.body.size));
+                delete requestInit.duplex;
+            }
+            else if ((0, isReadableStreamLike_1.isReadableStreamLike)(body)) {
+                contentType = 'application/octet-stream';
+                requestInit.duplex = 'half'; // undici library requires "duplex" option to be set for streams
+            }
+            else if (Buffer.isBuffer(body)) {
+                contentType = 'application/octet-stream';
+                headers.set('Content-Length', String(body.length));
+                delete requestInit.duplex;
+            }
+            else if ((0, common_1.isBlob)(body)) {
+                contentType = body.type || 'application/octet-stream';
+                headers.set('Content-Length', String(body.size));
+                delete requestInit.duplex;
+            }
+            else {
+                contentType = 'application/json;charset="UTF-8"';
+                requestInit.body = new Blob([JSON.stringify(body)], { type: contentType });
+                headers.set('Content-Length', String(requestInit.body.size));
+                delete requestInit.duplex;
+            }
+            if (contentType && !headers.has('Content-Type'))
+                headers.set('Content-Type', contentType);
+        }
+        return new Request(requestInit.url.toString(), requestInit);
+    }
+    createResponse(init) {
+        return new http_response_js_1.HttpResponse(init);
+    }
+    async parseBody(fetchResponse) {
+        let body;
+        const contentType = (fetchResponse.headers.get('Content-Type') || '');
+        if (type_is_1.default.is(contentType, ['json', 'application/*+json'])) {
+            body = await fetchResponse.json();
+            if (typeof body === 'string')
+                body = JSON.parse(body);
+        }
+        else if (type_is_1.default.is(contentType, ['text']))
+            body = await fetchResponse.text();
+        else if (type_is_1.default.is(contentType, ['multipart']))
+            body = await fetchResponse.formData();
+        else {
+            const buf = await fetchResponse.arrayBuffer();
+            if (buf.byteLength)
+                body = buf;
+        }
+        return body;
+    }
+}
+exports.FetchBackend = FetchBackend;

package/cjs/http/http-backend.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpBackend = void 0;
+const backend_js_1 = require("../core/backend.js");
+/**
+ *
+ * @class HttpBackend
+ */
+class HttpBackend extends backend_js_1.Backend {
+    constructor(serviceUrl, options) {
+        super(options);
+        this.serviceUrl = serviceUrl;
+    }
+}
+exports.HttpBackend = HttpBackend;

package/cjs/http/http-client-base.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientBase = void 0;
+const common_1 = require("@opra/common");
+const constants_js_1 = require("../constants.js");
+const client_base_js_1 = require("../core/client-base.js");
+const http_collection_node_js_1 = require("./http-collection-node.js");
+const http_request_observable_js_1 = require("./http-request-observable.js");
+const http_singleton_node_js_1 = require("./http-singleton-node.js");
+/**
+ *
+ * @class OpraClientBase
+ * @abstract
+ */
+class HttpClientBase extends client_base_js_1.ClientBase {
+    constructor(backend) {
+        super(backend);
+    }
+    get serviceUrl() {
+        return this[constants_js_1.kBackend].serviceUrl;
+    }
+    async getMetadata() {
+        let promise = this._metadataPromise;
+        if (promise)
+            return promise;
+        const request = new http_request_observable_js_1.HttpRequestObservable(this[constants_js_1.kBackend], {
+            method: 'GET',
+            url: '/',
+            headers: new Headers({ 'accept': 'application/json' })
+        });
+        this._metadataPromise = promise = request.getBody();
+        return await promise
+            .then(async (body) => {
+            if (!body)
+                throw new Error(`No response returned.`);
+            const api = await common_1.ApiDocumentFactory.createDocument(body);
+            this[constants_js_1.kBackend].api = api;
+            return api;
+        })
+            .catch((e) => {
+            e.message = 'Unable to fetch metadata from service url (' + this.serviceUrl + '). ' + e.message;
+            throw e;
+        })
+            .finally(() => delete this._metadataPromise);
+    }
+    collection(path) {
+        return new http_collection_node_js_1.HttpCollectionNode(this[constants_js_1.kBackend], path);
+    }
+    singleton(path) {
+        return new http_singleton_node_js_1.HttpSingletonNode(this[constants_js_1.kBackend], path);
+    }
+    action(path, params) {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this[constants_js_1.kBackend], {
+            method: 'GET',
+            url: path
+        });
+        if (params) {
+            Object.keys(params).forEach(k => params[k] = String(params[k]));
+            observable.param(params);
+        }
+        return observable;
+    }
+}
+exports.HttpClientBase = HttpClientBase;

package/cjs/http/http-client.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpClient = void 0;
+const constants_js_1 = require("../constants.js");
+const fetch_backend_js_1 = require("./fetch-backend.js");
+const http_client_base_js_1 = require("./http-client-base.js");
+/**
+ *
+ * @class OpraHttpClient
+ */
+class OpraHttpClient extends http_client_base_js_1.HttpClientBase {
+    constructor(serviceUrl, options) {
+        super(new fetch_backend_js_1.FetchBackend(serviceUrl, options));
+    }
+    get defaults() {
+        return this[constants_js_1.kBackend].defaults;
+    }
+}
+exports.OpraHttpClient = OpraHttpClient;

package/cjs/{impl/collection-node.js → http/http-collection-node.js}

@@ -8,12 +8,12 @@ const http_request_observable_js_1 = require("./http-request-observable.js");
  * @class HttpCollectionNode
  */
 class HttpCollectionNode {
-    constructor(client, path) {
-        this._client = client;
+    constructor(backend, path) {
+        this._backend = backend;
         this._path = path;
     }
     create(data, options) {
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'POST',
             url: this._path,
             body: data
@@ -31,13 +31,13 @@ class HttpCollectionNode {
             throw new TypeError(`'id' argument must have a value`);
         const url = new common_1.OpraURL();
         url.join({ resource: this._path, key: id });
-        return new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        return new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'DELETE',
             url
         });
     }
     deleteMany(options) {
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'DELETE',
             url: this._path
         });
@@ -50,7 +50,7 @@ class HttpCollectionNode {
             throw new TypeError(`'id' argument must have a value`);
         const url = new common_1.OpraURL();
         url.join({ resource: this._path, key: id });
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'GET',
             url
         });
@@ -63,7 +63,7 @@ class HttpCollectionNode {
         return observable;
     }
     findMany(options) {
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'GET',
             url: this._path
         });
@@ -92,7 +92,7 @@ class HttpCollectionNode {
             throw new TypeError(`'id' argument must have a value`);
         const url = new common_1.OpraURL();
         url.join({ resource: this._path, key: id });
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'PATCH',
             url,
             body: data
@@ -106,7 +106,7 @@ class HttpCollectionNode {
         return observable;
     }
     updateMany(data, options) {
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'PATCH',
             url: this._path,
             body: data

package/cjs/http/http-fetch-client.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpFetchClient = void 0;
+const constants_js_1 = require("../constants.js");
+const fetch_backend_js_1 = require("./fetch-backend.js");
+const http_client_base_js_1 = require("./http-client-base.js");
+/**
+ *
+ * @class HttpFetchClient
+ */
+class HttpFetchClient extends http_client_base_js_1.HttpClientBase {
+    constructor(serviceUrl, options) {
+        super(new fetch_backend_js_1.FetchBackend(serviceUrl, options));
+    }
+    get defaults() {
+        return this[constants_js_1.kBackend].defaults;
+    }
+}
+exports.HttpFetchClient = HttpFetchClient;

package/cjs/http/http-interceptor-handler.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpInterceptorHandler = void 0;
+class HttpInterceptorHandler {
+    constructor(interceptors, finalHandler) {
+        this.chain = interceptors.reduceRight((chainTailFn, interceptor) => (initialRequest, handler) => interceptor.intercept(initialRequest, {
+            handle: (downstreamRequest) => chainTailFn(downstreamRequest, handler)
+        }), chainEnd);
+        this.finalHandler = finalHandler;
+    }
+    handle(initialRequest) {
+        return this.chain(initialRequest, (req) => this.finalHandler.handle(req));
+    }
+}
+exports.HttpInterceptorHandler = HttpInterceptorHandler;
+function chainEnd(req, handler) {
+    return handler(req);
+}

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestObservable = void 0;
+const tslib_1 = require("tslib");
+const rxjs_1 = require("rxjs");
+const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
+const common_1 = require("@opra/common");
+const constants_js_1 = require("../constants.js");
+const client_error_js_1 = require("../core/client-error.js");
+const http_observable_type_enum_js_1 = require("./enums/http-observable-type.enum.js");
+const http_interceptor_handler_js_1 = require("./http-interceptor-handler.js");
+const http_event_js_1 = require("./interfaces/http-event.js");
+/**
+ *
+ * @class HttpRequestObservable
+ */
+class HttpRequestObservable extends rxjs_1.Observable {
+    constructor(backend, init) {
+        super((subscriber) => {
+            const observe = this[constants_js_1.kContext].observe;
+            new http_interceptor_handler_js_1.HttpInterceptorHandler(backend.interceptors || [], this[constants_js_1.kBackend])
+                .handle(this[constants_js_1.kContext])
+                .subscribe({
+                next(event) {
+                    if (observe === http_observable_type_enum_js_1.HttpObserveType.Events) {
+                        subscriber.next(event);
+                        return;
+                    }
+                    if (observe === http_observable_type_enum_js_1.HttpObserveType.ResponseHeader && event.type === http_event_js_1.HttpEventType.ResponseHeader) {
+                        subscriber.next(event.response);
+                        subscriber.complete();
+                        return;
+                    }
+                    if (event.type === http_event_js_1.HttpEventType.Response) {
+                        const { response } = event;
+                        if (observe === http_observable_type_enum_js_1.HttpObserveType.Response) {
+                            subscriber.next(response);
+                            subscriber.complete();
+                            return;
+                        }
+                        const isOpraResponse = type_is_1.default.is(event.response.contentType || '', ['application/opra+json']);
+                        if (response.status >= 400 && response.status < 600) {
+                            subscriber.error(new client_error_js_1.ClientError({
+                                message: response.status + ' ' + response.statusText,
+                                status: response.status,
+                                issues: isOpraResponse ? response.body.errors : undefined
+                            }));
+                            subscriber.complete();
+                            return;
+                        }
+                        subscriber.next(event.response.body);
+                        subscriber.complete();
+                    }
+                },
+                error(error) {
+                    subscriber.error(error);
+                },
+                complete() {
+                    subscriber.complete();
+                }
+            });
+        });
+        Object.defineProperty(this, constants_js_1.kBackend, {
+            enumerable: false,
+            value: backend
+        });
+        const url = new common_1.OpraURL(init?.url, backend.serviceUrl.toString());
+        Object.defineProperty(this, constants_js_1.kContext, {
+            enumerable: false,
+            value: {
+                ...init,
+                observe: http_observable_type_enum_js_1.HttpObserveType.Body,
+                headers: new Headers(init?.headers),
+                url,
+            }
+        });
+    }
+    clone() {
+        return new HttpRequestObservable(this[constants_js_1.kBackend], this[constants_js_1.kContext]);
+    }
+    options(options) {
+        Object.assign(this[constants_js_1.kContext], options);
+        return this;
+    }
+    header(arg0, value) {
+        const target = this[constants_js_1.kContext].headers;
+        if (typeof arg0 === 'object') {
+            const h = arg0 instanceof Headers
+                ? arg0
+                : new Headers(arg0);
+            h.forEach((v, k) => {
+                if (k.toLowerCase() === 'set-cookie') {
+                    target.append(k, v);
+                }
+                else
+                    target.set(k, v);
+            });
+            return this;
+        }
+        if (value == null || value === '')
+            target.delete(arg0);
+        else
+            target.append(arg0, String(value));
+        return this;
+    }
+    param(arg0, value) {
+        const target = this[constants_js_1.kContext].url.searchParams;
+        if (typeof arg0 === 'object') {
+            const h = arg0 instanceof URLSearchParams
+                ? arg0
+                : new URLSearchParams(arg0);
+            h.forEach((v, k) => target.set(k, v));
+            return this;
+        }
+        if (value == null)
+            target.delete(arg0);
+        else
+            target.set(arg0, String(value));
+        return this;
+    }
+    observe(observe) {
+        if (observe === this[constants_js_1.kContext].observe)
+            return this;
+        const cloned = this.clone();
+        cloned[constants_js_1.kContext].observe = observe || http_observable_type_enum_js_1.HttpObserveType.Body;
+        return cloned;
+    }
+    getBody() {
+        return (0, rxjs_1.lastValueFrom)(this.observe(http_observable_type_enum_js_1.HttpObserveType.Body));
+    }
+    getResponse() {
+        return (0, rxjs_1.lastValueFrom)(this.observe(http_observable_type_enum_js_1.HttpObserveType.Response));
+    }
+}
+exports.HttpRequestObservable = HttpRequestObservable;

package/cjs/{impl → http}/http-response.js

@@ -15,6 +15,7 @@ class HttpResponse {
         this.ok = this.status >= 200 && this.status < 300;
         this.body = init?.body;
         this.hasBody = init?.body != null || !!init?.hasBody;
+        this.contentType = (this.headers.get('content-type') || '').split(';')[0];
     }
     clone(update) {
         return new HttpResponse({ ...this, ...update });

package/cjs/{impl → http}/http-service-base.js

@@ -6,7 +6,7 @@ const constants_js_1 = require("../constants.js");
 class HttpServiceBase {
     constructor(client) {
         this[_a] = {
-            resource: {},
+            resources: {},
             node: null
         };
         this[constants_js_1.kClient] = client;

package/cjs/{impl/singleton-node.js → http/http-singleton-node.js}

@@ -7,12 +7,12 @@ const http_request_observable_js_1 = require("./http-request-observable.js");
  * @class HttpSingletonNode
  */
 class HttpSingletonNode {
-    constructor(client, path) {
-        this._client = client;
+    constructor(backend, path) {
+        this._backend = backend;
         this._path = path;
     }
     create(data, options) {
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'POST',
             url: this._path,
             body: data
@@ -26,13 +26,13 @@ class HttpSingletonNode {
         return observable;
     }
     delete() {
-        return new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        return new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'DELETE',
             url: this._path
         });
     }
     get(options) {
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'GET',
             url: this._path
         });
@@ -45,7 +45,7 @@ class HttpSingletonNode {
         return observable;
     }
     update(data, options) {
-        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._backend, {
             method: 'PATCH',
             url: this._path,
             body: data