@utiliread/http 1.10.2 → 1.13.0

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);
+    }
 }

package/src/http.spec.ts

@@ -1,104 +1,104 @@
-import { expect } from "chai";
-import { Http } from "./http";
-import "./json";
-
-describe("static http", () => {
-  it("can get", () => {
-    const builder = Http.get("hello");
-    expect(builder.getUrl()).to.equal("hello");
-    expect(builder.options.fetch).to.equal(Http.defaults.fetch);
-  });
-
-  it("can get with leading /", () => {
-    const builder = Http.get("/hello");
-    expect(builder.getUrl()).to.equal("/hello");
-    expect(builder.options.fetch).to.equal(Http.defaults.fetch);
-  });
-
-  it("can get with changed default fetch", () => {
-    Http.get("/hello"); // Creates internal singleton
-    // Change static default after request is created
-    const fetch = Http.defaults.fetch;
-    Http.defaults.fetch = fakeFetch;
-    const builder = Http.get("/hello");
-    expect(builder.options.fetch).to.equal(fakeFetch);
-    Http.defaults.fetch = fetch;
-  });
-});
-
-describe("instance http", () => {
-  it("can get with different timeout", () => {
-    const http = new Http();
-    const builder = http.get("/hello");
-    expect(builder.options.fetch).to.equal(Http.defaults.fetch);
-    expect(builder.options.timeout).to.equal(undefined);
-  });
-
-  it("can get with different timeout", () => {
-    const http = new Http({ timeout: 123 });
-    const builder = http.get("/hello");
-    expect(builder.options.fetch).to.equal(Http.defaults.fetch);
-    expect(builder.options.timeout).to.equal(123);
-  });
-
-  it("can get with different fetch", () => {
-    const http = new Http({ fetch: fakeFetch });
-    const builder = http.get("/hello");
-    expect(builder.options.fetch).to.equal(fakeFetch);
-    expect(builder.options.timeout).to.equal(undefined);
-  });
-
-  it("can get hello with base url", () => {
-    const http = new Http({ baseUrl: "base" });
-    const builder = http.get("hello");
-    expect(builder.getUrl()).to.equal("base/hello");
-  });
-
-  it("can get hello with base/", () => {
-    const http = new Http({ baseUrl: "base/" });
-    const builder = http.get("hello");
-    expect(builder.getUrl()).to.equal("base/hello");
-  });
-
-  it("can get /hello with base url", () => {
-    const http = new Http({ baseUrl: "base" });
-    const builder = http.get("/hello");
-    expect(builder.getUrl()).to.equal("base/hello");
-  });
-
-  it("can get /hello with base/", () => {
-    const http = new Http({ baseUrl: "base/" });
-    const builder = http.get("/hello");
-    expect(builder.getUrl()).to.equal("base/hello");
-  });
-
-  it("can post json, with then expect", async () => {
-    const user = await new Http()
-      .post("https://reqres.in/api/users")
-      .withJson({
-        name: "morpheus",
-        job: "leader",
-      })
-      .expectJson<{ name: string; job: string }>()
-      .transfer();
-
-    expect(user.name).to.equal("morpheus");
-  });
-
-  it("can post json, expect then with", async () => {
-    const user = await new Http()
-      .post("https://reqres.in/api/users")
-      .expectJson<{ name: string; job: string }>()
-      .withJson({
-        name: "morpheus",
-        job: "leader",
-      })
-      .transfer();
-
-    expect(user.name).to.equal("morpheus");
-  }).timeout(5000);
-});
-
-function fakeFetch(input: RequestInfo, init?: RequestInit): Promise<Response> {
-  return Promise.resolve(new Response());
-}
+import { expect } from "chai";
+import { Http } from "./http";
+import "./json";
+
+describe("static http", () => {
+  it("can get", () => {
+    const builder = Http.get("hello");
+    expect(builder.getUrl()).to.equal("hello");
+    expect(builder.options.fetch).to.equal(Http.defaults.fetch);
+  });
+
+  it("can get with leading /", () => {
+    const builder = Http.get("/hello");
+    expect(builder.getUrl()).to.equal("/hello");
+    expect(builder.options.fetch).to.equal(Http.defaults.fetch);
+  });
+
+  it("can get with changed default fetch", () => {
+    Http.get("/hello"); // Creates internal singleton
+    // Change static default after request is created
+    const fetch = Http.defaults.fetch;
+    Http.defaults.fetch = fakeFetch;
+    const builder = Http.get("/hello");
+    expect(builder.options.fetch).to.equal(fakeFetch);
+    Http.defaults.fetch = fetch;
+  });
+});
+
+describe("instance http", () => {
+  it("can get with different timeout", () => {
+    const http = new Http();
+    const builder = http.get("/hello");
+    expect(builder.options.fetch).to.equal(Http.defaults.fetch);
+    expect(builder.options.timeout).to.equal(undefined);
+  });
+
+  it("can get with different timeout", () => {
+    const http = new Http({ timeout: 123 });
+    const builder = http.get("/hello");
+    expect(builder.options.fetch).to.equal(Http.defaults.fetch);
+    expect(builder.options.timeout).to.equal(123);
+  });
+
+  it("can get with different fetch", () => {
+    const http = new Http({ fetch: fakeFetch });
+    const builder = http.get("/hello");
+    expect(builder.options.fetch).to.equal(fakeFetch);
+    expect(builder.options.timeout).to.equal(undefined);
+  });
+
+  it("can get hello with base url", () => {
+    const http = new Http({ baseUrl: "base" });
+    const builder = http.get("hello");
+    expect(builder.getUrl()).to.equal("base/hello");
+  });
+
+  it("can get hello with base/", () => {
+    const http = new Http({ baseUrl: "base/" });
+    const builder = http.get("hello");
+    expect(builder.getUrl()).to.equal("base/hello");
+  });
+
+  it("can get /hello with base url", () => {
+    const http = new Http({ baseUrl: "base" });
+    const builder = http.get("/hello");
+    expect(builder.getUrl()).to.equal("base/hello");
+  });
+
+  it("can get /hello with base/", () => {
+    const http = new Http({ baseUrl: "base/" });
+    const builder = http.get("/hello");
+    expect(builder.getUrl()).to.equal("base/hello");
+  });
+
+  it("can post json, with then expect", async () => {
+    const user = await new Http()
+      .post("https://reqres.in/api/users")
+      .withJson({
+        name: "morpheus",
+        job: "leader",
+      })
+      .expectJson<{ name: string; job: string }>()
+      .transfer();
+
+    expect(user.name).to.equal("morpheus");
+  });
+
+  it("can post json, expect then with", async () => {
+    const user = await new Http()
+      .post("https://reqres.in/api/users")
+      .expectJson<{ name: string; job: string }>()
+      .withJson({
+        name: "morpheus",
+        job: "leader",
+      })
+      .transfer();
+
+    expect(user.name).to.equal("morpheus");
+  }).timeout(5000);
+});
+
+function fakeFetch(input: RequestInfo, init?: RequestInit): Promise<Response> {
+  return Promise.resolve(new Response());
+}

package/src/http.ts

@@ -1,121 +1,122 @@
-import { EventAggregator } from './event-aggregator';
-import { HttpBuilder, HttpMethod, Message } from './http-builder';
-import { HttpResponse, HttpResponseOfT } from './http-response';
-import { QueryString } from './query-string';
-
-export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
-
-export class Http {
-    static defaults: HttpOptions = {
-        fetch: window.fetch ? window.fetch.bind(window) : undefined,
-    }
-    private static instance?: Http;
-    options: HttpOptions;
-    /** @internal */
-    _onSend = new EventAggregator<[Message]>();
-    /** @internal */
-    _onSent = new EventAggregator<[HttpResponse, Message]>();
-    /** @internal */
-    _onReceived = new EventAggregator<[HttpResponseOfT<any>, Message, any]>();
-
-    constructor(options?: Partial<HttpOptions>) {
-        this.options = Object.assign({}, Http.defaults, options); // Later sources' properties overwrite earlier ones.
-    }
-
-    static request(method: HttpMethod, url: string, params?: any) {
-        return this.getInstance().request(method, url, params);
-    }
-
-    static head(url: string, params?: any) {
-        return this.getInstance().head(url, params);
-    }
-
-    static post(url: string, params?: any) {
-        return this.getInstance().post(url, params);
-    }
-
-    static get(url: string, params?: any) {
-        return this.getInstance().get(url, params);
-    }
-
-    static put(url: string, params?: any) {
-        return this.getInstance().put(url, params);
-    }
-
-    static patch(url: string, params?: any) {
-        return this.getInstance().patch(url, params);
-    }
-
-    static delete(url: string, params?: any) {
-        return this.getInstance().delete(url, params);
-    }
-
-    private static getInstance() {
-        if (!this.instance) {
-            this.instance = new Http();
-            // The singleton instance should always use the static options
-            this.instance.options = Http.defaults;
-        }
-        return this.instance;
-    }
-
-    request(method: HttpMethod, url: string, params?: any) {
-        const message = {
-            method,
-            url: url + QueryString.serialize(params),
-            headers: new Headers()
-        };
-        const fetch = this.options.fetch;
-        if (!fetch) {
-            throw Error('fetch() is not properly configured');
-        }
-        const builder = new HttpBuilder(message, {
-            fetch,
-            timeout: this.options.timeout,
-            baseUrl: this.options.baseUrl,
-        }, this);
-        return builder;
-    }
-
-    head(url: string, params?: any) {
-        return this.request('HEAD', url, params);
-    }
-
-    post(url: string, params?: any) {
-        return this.request('POST', url, params);
-    }
-
-    get(url: string, params?: any) {
-        return this.request('GET', url, params);
-    }
-
-    put(url: string, params?: any) {
-        return this.request('PUT', url, params);
-    }
-
-    patch(url: string, params?: any) {
-        return this.request('PATCH', url, params);
-    }
-
-    delete(url: string, params?: any) {
-        return this.request('DELETE', url, params);
-    }
-
-    onSend(callback: (request: Message) => void | Promise<void>) {
-        return this._onSend.subscribe(callback);
-    }
-
-    onSent(callback: (response: HttpResponse, request: Message) => void | Promise<void>) {
-        return this._onSent.subscribe(callback);
-    }
-
-    onReceived(callback: (response: HttpResponseOfT<any>, request: Message, value: any) => void | Promise<void>) {
-        return this._onReceived.subscribe(callback);
-    }
-}
-
-export interface HttpOptions {
-    fetch?: Fetch,
-    timeout?: number,
-    baseUrl?: string,
+import { EventAggregator } from './event-aggregator';
+import { HttpBuilder, HttpMethod, Message } from './http-builder';
+import { HttpResponse, HttpResponseOfT } from './http-response';
+import { QueryString } from './query-string';
+
+export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+export class Http {
+    static defaults: HttpOptions = {
+        fetch: window.fetch ? window.fetch.bind(window) : undefined,
+    }
+    private static instance?: Http;
+    options: HttpOptions;
+    /** @internal */
+    _onSend = new EventAggregator<[Message]>();
+    /** @internal */
+    _onSent = new EventAggregator<[HttpResponse, Message]>();
+    /** @internal */
+    _onReceived = new EventAggregator<[HttpResponseOfT<any>, Message, any]>();
+
+    constructor(options?: Partial<HttpOptions>) {
+        this.options = Object.assign({}, Http.defaults, options); // Later sources' properties overwrite earlier ones.
+    }
+
+    static request(method: HttpMethod, url: string, params?: any) {
+        return this.getInstance().request(method, url, params);
+    }
+
+    static head(url: string, params?: any) {
+        return this.getInstance().head(url, params);
+    }
+
+    static post(url: string, params?: any) {
+        return this.getInstance().post(url, params);
+    }
+
+    static get(url: string, params?: any) {
+        return this.getInstance().get(url, params);
+    }
+
+    static put(url: string, params?: any) {
+        return this.getInstance().put(url, params);
+    }
+
+    static patch(url: string, params?: any) {
+        return this.getInstance().patch(url, params);
+    }
+
+    static delete(url: string, params?: any) {
+        return this.getInstance().delete(url, params);
+    }
+
+    private static getInstance() {
+        if (!this.instance) {
+            this.instance = new Http();
+            // The singleton instance should always use the static options
+            this.instance.options = Http.defaults;
+        }
+        return this.instance;
+    }
+
+    request(method: HttpMethod, url: string, params?: any) {
+        const message = {
+            method,
+            url: url + QueryString.serialize(params),
+            headers: new Headers(),
+            properties: {},
+        };
+        const fetch = this.options.fetch;
+        if (!fetch) {
+            throw Error('fetch() is not properly configured');
+        }
+        const builder = new HttpBuilder(message, {
+            fetch,
+            timeout: this.options.timeout,
+            baseUrl: this.options.baseUrl,
+        }, this);
+        return builder;
+    }
+
+    head(url: string, params?: any) {
+        return this.request('HEAD', url, params);
+    }
+
+    post(url: string, params?: any) {
+        return this.request('POST', url, params);
+    }
+
+    get(url: string, params?: any) {
+        return this.request('GET', url, params);
+    }
+
+    put(url: string, params?: any) {
+        return this.request('PUT', url, params);
+    }
+
+    patch(url: string, params?: any) {
+        return this.request('PATCH', url, params);
+    }
+
+    delete(url: string, params?: any) {
+        return this.request('DELETE', url, params);
+    }
+
+    onSend(callback: (request: Message) => void | Promise<void>) {
+        return this._onSend.subscribe(callback);
+    }
+
+    onSent(callback: (response: HttpResponse, request: Message) => void | Promise<void>) {
+        return this._onSent.subscribe(callback);
+    }
+
+    onReceived(callback: (response: HttpResponseOfT<any>, request: Message, value: any) => void | Promise<void>) {
+        return this._onReceived.subscribe(callback);
+    }
+}
+
+export interface HttpOptions {
+    fetch?: Fetch,
+    timeout?: number,
+    baseUrl?: string,
 }

package/src/index.ts

@@ -1,16 +1,17 @@
-export { Http } from "./http";
-export {
-  Page,
-  PaginationResult,
-  InfinitePage,
-  InfinitePaginationResult,
-} from "./pagination";
-export { ProblemDetails } from "./problem-details";
-export { QueryString } from "./query-string";
-export { HttpResponse, HttpResponseOfT } from "./http-response";
-export { HttpBuilder, HttpBuilderOfT } from "./http-builder";
-export { HttpError } from "./http-error";
-export { TimeoutError } from "./timeout-error";
-export * from "./helpers";
-export { Fetch } from "./http";
-export { Subscription } from "./event-aggregator";
+export { Http } from "./http";
+export {
+  Page,
+  PaginationResult,
+  InfinitePage,
+  InfinitePaginationResult,
+} from "./pagination";
+export { ProblemDetails } from "./problem-details";
+export { QueryString } from "./query-string";
+export { HttpResponse, HttpResponseOfT } from "./http-response";
+export { HttpBuilder, HttpBuilderOfT, Message } from "./http-builder";
+export { HttpError } from "./http-error";
+export { TimeoutError } from "./timeout-error";
+export { events } from "./events";
+export * from "./helpers";
+export { Fetch } from "./http";
+export { Subscription } from "./event-aggregator";