@opra/client/esm/http/http-request-observable.js

Opra Client package

import typeIs from '@browsery/type-is';
import { MimeTypes } from '@opra/common';
import { lastValueFrom, Observable } from 'rxjs';
import { kBackend, kContext } from '../constants.js';
import { ClientError } from '../core/client-error.js';
import { HttpObserveType } from './enums/http-observable-type.enum.js';
import { HttpInterceptorHandler } from './http-interceptor-handler.js';
import { HttpEventType } from './interfaces/http-event.js';
/**
 *
 * @class HttpRequestObservable
 */
export class HttpRequestObservable extends Observable {
    constructor(backend, init) {
        super(subscriber => {
            const observe = this[kContext].observe;
            new HttpInterceptorHandler(backend.interceptors || [], this[kBackend])
                .handle(this[kContext])
                .subscribe({
                next(event) {
                    if (observe === HttpObserveType.Events) {
                        subscriber.next(event);
                        return;
                    }
                    if (observe === HttpObserveType.ResponseHeader &&
                        event.type === HttpEventType.ResponseHeader) {
                        subscriber.next(event.response);
                        subscriber.complete();
                        return;
                    }
                    if (event.type === HttpEventType.Response) {
                        const { response } = event;
                        if (observe === HttpObserveType.Response) {
                            subscriber.next(response);
                            subscriber.complete();
                            return;
                        }
                        const isOpraResponse = typeIs.is(event.response.contentType || '', [MimeTypes.opra_response_json]);
                        if (response.status >= 400 && response.status < 600) {
                            subscriber.error(new 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, kBackend, {
            enumerable: false,
            value: backend,
        });
        Object.defineProperty(this, kContext, {
            enumerable: false,
            value: {
                ...init,
                observe: HttpObserveType.Body,
                headers: new Headers(init?.headers),
            },
        });
    }
    clone() {
        return new HttpRequestObservable(this[kBackend], this[kContext]);
    }
    options(options) {
        Object.assign(this[kContext], options);
        return this;
    }
    header(arg0, value) {
        const target = this[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) {
        if (value && typeof value === 'object') {
            value = JSON.stringify(value);
        }
        const target = this[kContext].url.searchParams;
        if (typeof arg0 === 'object') {
            if (typeof arg0.forEach === 'function') {
                arg0.forEach((v, k) => target.set(String(k), String(v)));
            }
            else {
                Object.entries(arg0).forEach(entry => target.set(String(entry[0]), String(entry[1])));
            }
            return this;
        }
        if (value == null)
            target.delete(arg0);
        else
            target.set(arg0, String(value));
        return this;
    }
    observe(observe) {
        if (observe === this[kContext].observe)
            return this;
        const cloned = this.clone();
        cloned[kContext].observe = observe || HttpObserveType.Body;
        return cloned;
    }
    getBody() {
        return lastValueFrom(this.observe(HttpObserveType.Body));
    }
    getResponse() {
        return lastValueFrom(this.observe(HttpObserveType.Response));
    }
}