@utiliread/http 1.10.0 → 1.12.0

package/src/http-builder.ts

@@ -1,254 +1,255 @@
-import { Fetch } from './http';
-import { HttpResponse, HttpResponseOfT } from './http-response';
-import { TimeoutError } from './timeout-error';
-import { EventAggregator } from './event-aggregator';
-import { Http } from '.';
-
-export class HttpBuilder {
-    private _ensureSuccessStatusCode = true;
-    private _onSend = new EventAggregator<[Message]>();
-    private _onSent = new EventAggregator<[HttpResponse, Message]>();
-
-    constructor(public message: Message, public options: RequestOptions, /** @internal */ public http: Http) {
-    }
-
-    onSend(callback: (request: Message) => void | Promise<void>) {
-        this._onSend.subscribe(callback);
-        return this;
-    }
-
-    onSent(callback: (response: HttpResponse, request: Message) => void | Promise<void>) {
-        this._onSent.subscribe(callback);
-        return this;
-    }
-
-    protected useHandler<T>(handler: (response: Response) => Promise<T>) {
-        return new HttpBuilderOfT<T>(this, handler);
-    }
-
-    async send(abortSignal?: AbortSignal) {
-        if (this.message.contentType) {
-            this.message.headers.set('Content-Type', this.message.contentType);
-        }
-
-        // Resolve the final url and assign it to the message
-        // This makes the final url apper in onSend, onSent, and on Received handlers
-        this.message.url = this.getUrl();
-
-        await this._onSend.publish(this.message);
-        await this.http._onSend.publish(this.message);
-
-        const init: RequestInit = {
-            method: this.message.method,
-            body: this.message.content,
-            headers: this.message.headers,
-            mode: this.message.mode
-        };
-
-        if (abortSignal || this.options.timeout) {
-            var outerController = new AbortController();
-            if (abortSignal) {
-                abortSignal.addEventListener("abort", () => {
-                    outerController.abort();
-                });
-            }
-
-            init.signal = outerController.signal;
-        }
-
-        const fetchResponsePromise = this.options.fetch(this.message.url, init);
-        let fetchResponse: Response;
-
-        if (this.options.timeout) {
-            fetchResponse = await Promise.race([
-                fetchResponsePromise,
-                new Promise<Response>((_, reject) => setTimeout(() => {
-                    outerController.abort();
-                    reject(new TimeoutError());
-                }, this.options.timeout))
-            ]);
-        }
-        else {
-            fetchResponse = await fetchResponsePromise;
-        }
-
-        const httpResponse = new HttpResponse(fetchResponse);
-
-        if (this._ensureSuccessStatusCode) {
-            httpResponse.ensureSuccessfulStatusCode();
-        }
-
-        await this._onSent.publish(httpResponse, this.message);
-        await this.http._onSent.publish(httpResponse, this.message);
-
-        return httpResponse;
-    }
-
-    getUrl() {
-        let baseUrl = this.options.baseUrl;
-        if (!baseUrl) {
-            return this.message.url;
-        }
-
-        if (baseUrl.endsWith('/')) {
-            baseUrl = baseUrl.substr(0, baseUrl.length - 1);
-        }
-
-        if (this.message.url.startsWith('/')) {
-            return baseUrl + this.message.url;
-        }
-        else {
-            return baseUrl + '/' + this.message.url;
-        }
-    }
-
-    ensureSuccessStatusCode(ensureSuccessStatusCode?: boolean) {
-        this._ensureSuccessStatusCode = ensureSuccessStatusCode === false ? false : true;
-
-        return this;
-    }
-
-    useCors(mode: RequestMode) {
-        this.message.mode = mode;
-        return this;
-    }
-
-    useTimeout(timeout: number | null) {
-        this.options.timeout = timeout || undefined;
-        return this;
-    }
-
-    // Content Extensions
-
-    with(content: any, contentType?: string) {
-        this.message.content = content;
-        this.message.contentType = contentType;
-        return this;
-    }
-
-    withForm(content: FormData) {
-        this.message.content = content;
-        this.message.contentType = undefined;
-        return this;
-    }
-
-    // Modifier Extensions
-
-    addHeader(name: string, value: string) {
-        this.message.headers.append(name, value);
-        return this;
-    }
-
-    // Expect Extensions
-
-    expectString() {
-        return this.useHandler(response => {
-            return response.text();
-        });
-    }
-
-    expectBinary() {
-        return this.useHandler(response => {
-            return response.arrayBuffer();
-        });
-    }
-}
-
-export class HttpBuilderOfT<T> extends HttpBuilder {
-    private _onReceived = new EventAggregator<[HttpResponseOfT<T>, Message, T]>();
-
-    constructor(private inner: HttpBuilder, private handler: (response: Response) => Promise<T>) {
-        super(inner.message, inner.options, inner.http);
-    }
-
-    onSend(callback: (request: Message) => void | Promise<void>) {
-        this.inner.onSend(callback);
-        return this;
-    }
-
-    onSent(callback: (response: HttpResponse, request: Message) => void | Promise<void>) {
-        this.inner.onSent(callback);
-        return this;
-    }
-
-    ensureSuccessStatusCode(ensureSuccessStatusCode?: boolean) {
-        this.inner.ensureSuccessStatusCode(ensureSuccessStatusCode);
-        return this;
-    }
-
-    useCors(mode: RequestMode) {
-        this.inner.useCors(mode);
-        return this;
-    }
-
-    useTimeout(timeout: number) {
-        this.inner.useTimeout(timeout);
-        return this;
-    }
-
-    allowEmptyResponse() {
-        if (this._onReceived.any) {
-            throw new Error("onReceived() must be called after allowEmptyResponse() because the callback type changes");
-        }
-
-        return new HttpBuilderOfT<T | null>(this.inner, response => {
-            if (response.status === 204) {
-                return Promise.resolve(null);
-            }
-
-            return this.handler(response);
-        });
-    }
-
-    onReceived(callback: (response: HttpResponseOfT<T>, request: Message, value: T) => void | Promise<void>) {
-        this._onReceived.subscribe(callback);
-        return this;
-    }
-
-    send(abortSignal?: AbortSignal) {
-        const responsePromise = this.inner.send(abortSignal).then(x => new HttpResponseOfT<T>(x.rawResponse, this.handler));
-
-        return asSendPromise(responsePromise, () => responsePromise.then(response => this.handleReceive(response)));
-    }
-
-    transfer(abortSignal?: AbortSignal) {
-        return this.send(abortSignal).then(response => this.handleReceive(response));
-    }
-
-    private async handleReceive(response: HttpResponseOfT<T>) {
-        const request = this.message;
-        const value = await response.receive();
-
-        await this._onReceived.publish(response, request, value);
-        await this.http._onReceived.publish(response, request, value);
-
-        return value;
-    }
-}
-
-export type HttpMethod = "HEAD" | "POST" | "GET" | "PUT" | "PATCH" | "DELETE";
-
-export interface Message {
-    method: HttpMethod;
-    url: string;
-    headers: Headers;
-    content?: any;
-    contentType?: string;
-    mode?: RequestMode;
-}
-
-export interface RequestOptions {
-    fetch: Fetch,
-    timeout?: number,
-    baseUrl?: string,
-}
-
-export interface SendPromise<T> extends Promise<HttpResponseOfT<T>> {
-    thenReceive(): Promise<T>;
-}
-
-function asSendPromise<T>(responsePromise: Promise<HttpResponse>, thenReceive: () => Promise<T>): SendPromise<T> {
-    const sendPromise = responsePromise as SendPromise<T>;
-    sendPromise.thenReceive = thenReceive;
-    return sendPromise;
+import { Fetch } from './http';
+import { HttpResponse, HttpResponseOfT } from './http-response';
+import { TimeoutError } from './timeout-error';
+import { EventAggregator } from './event-aggregator';
+import { Http } from '.';
+
+export class HttpBuilder {
+    private _ensureSuccessStatusCode = true;
+    private _onSend = new EventAggregator<[Message]>();
+    private _onSent = new EventAggregator<[HttpResponse, Message]>();
+
+    constructor(public message: Message, public options: RequestOptions, /** @internal */ public http: Http) {
+    }
+
+    onSend(callback: (request: Message) => void | Promise<void>) {
+        this._onSend.subscribe(callback);
+        return this;
+    }
+
+    onSent(callback: (response: HttpResponse, request: Message) => void | Promise<void>) {
+        this._onSent.subscribe(callback);
+        return this;
+    }
+
+    protected useHandler<T>(handler: (response: Response) => Promise<T>) {
+        return new HttpBuilderOfT<T>(this, handler);
+    }
+
+    async send(abortSignal?: AbortSignal) {
+        if (this.message.contentType) {
+            this.message.headers.set('Content-Type', this.message.contentType);
+        }
+
+        // Resolve the final url and assign it to the message
+        // This makes the final url apper in onSend, onSent, and on Received handlers
+        this.message.url = this.getUrl();
+
+        await this._onSend.publish(this.message);
+        await this.http._onSend.publish(this.message);
+
+        const init: RequestInit = {
+            method: this.message.method,
+            body: this.message.content,
+            headers: this.message.headers,
+            mode: this.message.mode
+        };
+
+        if (abortSignal || this.options.timeout) {
+            var outerController = new AbortController();
+            if (abortSignal) {
+                abortSignal.addEventListener("abort", () => {
+                    outerController.abort();
+                });
+            }
+
+            init.signal = outerController.signal;
+        }
+
+        const fetchResponsePromise = this.options.fetch(this.message.url, init);
+        let fetchResponse: Response;
+
+        if (this.options.timeout) {
+            fetchResponse = await Promise.race([
+                fetchResponsePromise,
+                new Promise<Response>((_, reject) => setTimeout(() => {
+                    outerController.abort();
+                    reject(new TimeoutError());
+                }, this.options.timeout))
+            ]);
+        }
+        else {
+            fetchResponse = await fetchResponsePromise;
+        }
+
+        const httpResponse = new HttpResponse(fetchResponse);
+
+        if (this._ensureSuccessStatusCode) {
+            httpResponse.ensureSuccessfulStatusCode();
+        }
+
+        await this._onSent.publish(httpResponse, this.message);
+        await this.http._onSent.publish(httpResponse, this.message);
+
+        return httpResponse;
+    }
+
+    getUrl() {
+        let baseUrl = this.options.baseUrl;
+        if (!baseUrl) {
+            return this.message.url;
+        }
+
+        if (baseUrl.endsWith('/')) {
+            baseUrl = baseUrl.substr(0, baseUrl.length - 1);
+        }
+
+        if (this.message.url.startsWith('/')) {
+            return baseUrl + this.message.url;
+        }
+        else {
+            return baseUrl + '/' + this.message.url;
+        }
+    }
+
+    ensureSuccessStatusCode(ensureSuccessStatusCode?: boolean) {
+        this._ensureSuccessStatusCode = ensureSuccessStatusCode === false ? false : true;
+
+        return this;
+    }
+
+    useCors(mode: RequestMode) {
+        this.message.mode = mode;
+        return this;
+    }
+
+    useTimeout(timeout: number | null) {
+        this.options.timeout = timeout || undefined;
+        return this;
+    }
+
+    // Content Extensions
+
+    with(content: any, contentType?: string) {
+        this.message.content = content;
+        this.message.contentType = contentType;
+        return this;
+    }
+
+    withForm(content: FormData) {
+        this.message.content = content;
+        this.message.contentType = undefined;
+        return this;
+    }
+
+    // Modifier Extensions
+
+    addHeader(name: string, value: string) {
+        this.message.headers.append(name, value);
+        return this;
+    }
+
+    // Expect Extensions
+
+    expectString() {
+        return this.useHandler(response => {
+            return response.text();
+        });
+    }
+
+    expectBinary() {
+        return this.useHandler(response => {
+            return response.arrayBuffer();
+        });
+    }
+}
+
+export class HttpBuilderOfT<T> extends HttpBuilder {
+    private _onReceived = new EventAggregator<[HttpResponseOfT<T>, Message, T]>();
+
+    constructor(private inner: HttpBuilder, private handler: (response: Response) => Promise<T>) {
+        super(inner.message, inner.options, inner.http);
+    }
+
+    onSend(callback: (request: Message) => void | Promise<void>) {
+        this.inner.onSend(callback);
+        return this;
+    }
+
+    onSent(callback: (response: HttpResponse, request: Message) => void | Promise<void>) {
+        this.inner.onSent(callback);
+        return this;
+    }
+
+    ensureSuccessStatusCode(ensureSuccessStatusCode?: boolean) {
+        this.inner.ensureSuccessStatusCode(ensureSuccessStatusCode);
+        return this;
+    }
+
+    useCors(mode: RequestMode) {
+        this.inner.useCors(mode);
+        return this;
+    }
+
+    useTimeout(timeout: number) {
+        this.inner.useTimeout(timeout);
+        return this;
+    }
+
+    allowEmptyResponse() {
+        if (this._onReceived.any) {
+            throw new Error("onReceived() must be called after allowEmptyResponse() because the callback type changes");
+        }
+
+        return new HttpBuilderOfT<T | null>(this.inner, response => {
+            if (response.status === 204) {
+                return Promise.resolve(null);
+            }
+
+            return this.handler(response);
+        });
+    }
+
+    onReceived(callback: (response: HttpResponseOfT<T>, request: Message, value: T) => void | Promise<void>) {
+        this._onReceived.subscribe(callback);
+        return this;
+    }
+
+    send(abortSignal?: AbortSignal) {
+        const responsePromise = this.inner.send(abortSignal).then(x => new HttpResponseOfT<T>(x.rawResponse, this.handler));
+
+        return asSendPromise(responsePromise, () => responsePromise.then(response => this.handleReceive(response)));
+    }
+
+    transfer(abortSignal?: AbortSignal) {
+        return this.send(abortSignal).then(response => this.handleReceive(response));
+    }
+
+    private async handleReceive(response: HttpResponseOfT<T>) {
+        const request = this.message;
+        const value = await response.receive();
+
+        await this._onReceived.publish(response, request, value);
+        await this.http._onReceived.publish(response, request, value);
+
+        return value;
+    }
+}
+
+export type HttpMethod = "HEAD" | "POST" | "GET" | "PUT" | "PATCH" | "DELETE";
+
+export interface Message {
+    method: HttpMethod;
+    url: string;
+    headers: Headers;
+    content?: any;
+    contentType?: string;
+    mode?: RequestMode;
+    properties: {[key: string]: any};
+}
+
+export interface RequestOptions {
+    fetch: Fetch,
+    timeout?: number,
+    baseUrl?: string,
+}
+
+export interface SendPromise<T> extends Promise<HttpResponseOfT<T>> {
+    thenReceive(): Promise<T>;
+}
+
+function asSendPromise<T>(responsePromise: Promise<HttpResponse>, thenReceive: () => Promise<T>): SendPromise<T> {
+    const sendPromise = responsePromise as SendPromise<T>;
+    sendPromise.thenReceive = thenReceive;
+    return sendPromise;
 }

package/src/http-error.ts

@@ -1,26 +1,26 @@
-import { HttpResponse } from './http-response';
-import { ProblemDetails } from './problem-details';
-
-export class HttpError extends Error {
-    constructor(public statusCode: number, private response: HttpResponse | undefined = undefined) {
-        super(`The response was not successful: ${statusCode}`);
-        this.name = 'HttpError';
-
-        // Set the prototype explicitly to allow for "... instanceof HttpError",
-        // see https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        Object.setPrototypeOf(this, HttpError.prototype);
-    }
-
-    details<TDetails = ProblemDetails>() {
-        const rawResponse = this.response?.rawResponse;
-
-        if (rawResponse) {
-            const contentType = rawResponse.headers.get("Content-Type");
-            if (contentType && contentType.includes("application/problem+json")) {
-                return rawResponse.json().then(details => <TDetails>details);
-            }
-        }
-
-        return Promise.reject(new Error("There are no problem details in the response"));
-    }
+import { HttpResponse } from './http-response';
+import { ProblemDetails } from './problem-details';
+
+export class HttpError extends Error {
+    constructor(public statusCode: number, private response: HttpResponse | undefined = undefined) {
+        super(`The response was not successful: ${statusCode}`);
+        this.name = 'HttpError';
+
+        // Set the prototype explicitly to allow for "... instanceof HttpError",
+        // see https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        Object.setPrototypeOf(this, HttpError.prototype);
+    }
+
+    details<TDetails = ProblemDetails>() {
+        const rawResponse = this.response?.rawResponse;
+
+        if (rawResponse) {
+            const contentType = rawResponse.headers.get("Content-Type");
+            if (contentType && contentType.includes("application/problem+json")) {
+                return rawResponse.json().then(details => <TDetails>details);
+            }
+        }
+
+        return Promise.reject(new Error("There are no problem details in the response"));
+    }
 }

package/src/http-response.ts

@@ -1,56 +1,56 @@
-import { HttpError } from "./http-error";
-
-export class HttpResponse {
-    get url() {
-        return this.rawResponse.url;
-    }
-
-    get statusCode() {
-        return this.rawResponse.status;
-    }
-
-    get headers() {
-        return this.rawResponse.headers;
-    }
-
-    get isInformational() {
-        return this.statusCode >= 100 && this.statusCode < 200;
-    }
-
-    get isSuccessful() {
-        return this.statusCode >= 200 && this.statusCode < 300;
-    }
-
-    get isRedirection() {
-        return this.statusCode >= 300 && this.statusCode < 400;
-    }
-
-    get isClientError() {
-        return this.statusCode >= 400 && this.statusCode < 500;
-    }
-
-    get isServerError() {
-        return this.statusCode >= 500 && this.statusCode < 600;
-    }
-    
-    constructor(public rawResponse: Response) {
-    }
-
-    ensureSuccessfulStatusCode() {
-        if (!this.isSuccessful) {
-            throw new HttpError(this.statusCode, this);
-        }
-
-        return this;
-    }
-}
-
-export class HttpResponseOfT<T> extends HttpResponse {
-    constructor(rawResponse: Response, private handler: (response: Response) => Promise<T>) {
-        super(rawResponse);
-    }
-
-    receive() {
-        return this.handler(this.rawResponse);
-    }
+import { HttpError } from "./http-error";
+
+export class HttpResponse {
+    get url() {
+        return this.rawResponse.url;
+    }
+
+    get statusCode() {
+        return this.rawResponse.status;
+    }
+
+    get headers() {
+        return this.rawResponse.headers;
+    }
+
+    get isInformational() {
+        return this.statusCode >= 100 && this.statusCode < 200;
+    }
+
+    get isSuccessful() {
+        return this.statusCode >= 200 && this.statusCode < 300;
+    }
+
+    get isRedirection() {
+        return this.statusCode >= 300 && this.statusCode < 400;
+    }
+
+    get isClientError() {
+        return this.statusCode >= 400 && this.statusCode < 500;
+    }
+
+    get isServerError() {
+        return this.statusCode >= 500 && this.statusCode < 600;
+    }
+    
+    constructor(public rawResponse: Response) {
+    }
+
+    ensureSuccessfulStatusCode() {
+        if (!this.isSuccessful) {
+            throw new HttpError(this.statusCode, this);
+        }
+
+        return this;
+    }
+}
+
+export class HttpResponseOfT<T> extends HttpResponse {
+    constructor(rawResponse: Response, private handler: (response: Response) => Promise<T>) {
+        super(rawResponse);
+    }
+
+    receive() {
+        return this.handler(this.rawResponse);
+    }
 }