@utiliread/http 1.11.0 → 1.13.1

package/src/json.ts

@@ -1,138 +1,138 @@
-import { HttpBuilder, HttpBuilderOfT } from "./http-builder";
-import { InfinitePaginationResult, PaginationResult } from "./pagination";
-import { deserialize, serialize } from "@utiliread/json";
-import { getMapper, getNullableMapper, Mapper, Type } from "./mapping";
-import type { Operation } from "@utiliread/jsonpatch";
-
-type TypeOrMapper<T> = Type<T> | Mapper<T>;
-
-declare module "./http-builder" {
-  interface HttpBuilder {
-    withJson(content: any): this;
-    withJsonPatch(operations: Operation[]): this;
-
-    expectJson<T>(typeOrMapper?: TypeOrMapper<T>): HttpBuilderOfT<T>;
-    expectJsonArray<T>(typeOrMapper: TypeOrMapper<T>): HttpBuilderOfT<T[]>;
-    expectJsonNullableArray<T>(
-      typeOrMapper: TypeOrMapper<T>
-    ): HttpBuilderOfT<(T | null)[]>;
-    expectJsonPaginationResult<T>(
-      typeOrMapper: TypeOrMapper<T>
-    ): HttpBuilderOfT<PaginationResult<T>>;
-    expectJsonInfinitePaginationResult<T>(
-      typeOrMapper: TypeOrMapper<T>
-    ): HttpBuilderOfT<InfinitePaginationResult<T>>;
-  }
-  interface HttpBuilderOfT<T> {
-    withJson(content: any): this;
-    withJsonPatch(operations: Operation[]): this;
-  }
-}
-
-HttpBuilder.prototype.withJson = function (this: HttpBuilder, content: any) {
-  this.message.content = serialize(content);
-  this.message.contentType = "application/json";
-  return this;
-};
-
-HttpBuilder.prototype.withJsonPatch = function (
-  this: HttpBuilder,
-  operations: Operation[]
-) {
-  this.message.content = serialize(operations);
-  this.message.contentType = "application/json-patch+json";
-  return this;
-};
-
-HttpBuilderOfT.prototype.withJson = function <T>(
-  this: HttpBuilderOfT<T>,
-  content: any
-) {
-  this.message.content = serialize(content);
-  this.message.contentType = "application/json";
-  return this;
-};
-
-HttpBuilderOfT.prototype.withJsonPatch = function <T>(
-  this: HttpBuilderOfT<T>,
-  operations: Operation[]
-) {
-  this.message.content = serialize(operations);
-  this.message.contentType = "application/json-patch+json";
-  return this;
-};
-
-HttpBuilder.prototype.expectJson = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.json().then((x) => getMapper(deserialize, typeOrMapper)(x));
-  });
-};
-
-HttpBuilder.prototype.expectJsonArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.json().then((x: any[]) => {
-      const itemFactory = getMapper(deserialize, typeOrMapper);
-      return x.map(itemFactory);
-    });
-  });
-};
-
-HttpBuilder.prototype.expectJsonNullableArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: TypeOrMapper<T>
-): HttpBuilderOfT<(T | null)[]> {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.json().then((x: any[]) => {
-      const itemFactory = getNullableMapper(deserialize, typeOrMapper);
-      return x.map(itemFactory);
-    });
-  });
-};
-
-HttpBuilder.prototype.expectJsonPaginationResult = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.json().then((x: PaginationResult<any>) => {
-      const itemFactory = getMapper(deserialize, typeOrMapper);
-      return {
-        meta: {
-          pageCount: x.meta.pageCount,
-          pageSize: x.meta.pageSize,
-          totalItems: x.meta.totalItems,
-        },
-        data: x.data.map(itemFactory),
-      };
-    });
-  });
-};
-
-HttpBuilder.prototype.expectJsonInfinitePaginationResult = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.json().then((x: InfinitePaginationResult<any>) => {
-      const itemFactory = getMapper(deserialize, typeOrMapper);
-      return {
-        meta: {
-          pageSize: x.meta.pageSize,
-          continuationToken: x.meta.continuationToken,
-        },
-        data: x.data.map(itemFactory),
-      };
-    });
-  });
-};
+import { HttpBuilder, HttpBuilderOfT } from "./http-builder";
+import { InfinitePaginationResult, PaginationResult } from "./pagination";
+import { deserialize, serialize } from "@utiliread/json";
+import { getMapper, getNullableMapper, Mapper, Type } from "./mapping";
+import type { Operation } from "@utiliread/jsonpatch";
+
+type TypeOrMapper<T> = Type<T> | Mapper<T>;
+
+declare module "./http-builder" {
+  interface HttpBuilder {
+    withJson(content: any): this;
+    withJsonPatch(operations: Operation[]): this;
+
+    expectJson<T>(typeOrMapper?: TypeOrMapper<T>): HttpBuilderOfT<T>;
+    expectJsonArray<T>(typeOrMapper: TypeOrMapper<T>): HttpBuilderOfT<T[]>;
+    expectJsonNullableArray<T>(
+      typeOrMapper: TypeOrMapper<T>
+    ): HttpBuilderOfT<(T | null)[]>;
+    expectJsonPaginationResult<T>(
+      typeOrMapper: TypeOrMapper<T>
+    ): HttpBuilderOfT<PaginationResult<T>>;
+    expectJsonInfinitePaginationResult<T>(
+      typeOrMapper: TypeOrMapper<T>
+    ): HttpBuilderOfT<InfinitePaginationResult<T>>;
+  }
+  interface HttpBuilderOfT<T> {
+    withJson(content: any): this;
+    withJsonPatch(operations: Operation[]): this;
+  }
+}
+
+HttpBuilder.prototype.withJson = function (this: HttpBuilder, content: any) {
+  this.message.content = serialize(content);
+  this.message.contentType = "application/json";
+  return this;
+};
+
+HttpBuilder.prototype.withJsonPatch = function (
+  this: HttpBuilder,
+  operations: Operation[]
+) {
+  this.message.content = serialize(operations);
+  this.message.contentType = "application/json-patch+json";
+  return this;
+};
+
+HttpBuilderOfT.prototype.withJson = function <T>(
+  this: HttpBuilderOfT<T>,
+  content: any
+) {
+  this.message.content = serialize(content);
+  this.message.contentType = "application/json";
+  return this;
+};
+
+HttpBuilderOfT.prototype.withJsonPatch = function <T>(
+  this: HttpBuilderOfT<T>,
+  operations: Operation[]
+) {
+  this.message.content = serialize(operations);
+  this.message.contentType = "application/json-patch+json";
+  return this;
+};
+
+HttpBuilder.prototype.expectJson = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.json().then((x) => getMapper(deserialize, typeOrMapper)(x));
+  });
+};
+
+HttpBuilder.prototype.expectJsonArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.json().then((x: any[]) => {
+      const itemFactory = getMapper(deserialize, typeOrMapper);
+      return x.map(itemFactory);
+    });
+  });
+};
+
+HttpBuilder.prototype.expectJsonNullableArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: TypeOrMapper<T>
+): HttpBuilderOfT<(T | null)[]> {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.json().then((x: any[]) => {
+      const itemFactory = getNullableMapper(deserialize, typeOrMapper);
+      return x.map(itemFactory);
+    });
+  });
+};
+
+HttpBuilder.prototype.expectJsonPaginationResult = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.json().then((x: PaginationResult<any>) => {
+      const itemFactory = getMapper(deserialize, typeOrMapper);
+      return {
+        meta: {
+          pageCount: x.meta.pageCount,
+          pageSize: x.meta.pageSize,
+          totalItems: x.meta.totalItems,
+        },
+        data: x.data.map(itemFactory),
+      };
+    });
+  });
+};
+
+HttpBuilder.prototype.expectJsonInfinitePaginationResult = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.json().then((x: InfinitePaginationResult<any>) => {
+      const itemFactory = getMapper(deserialize, typeOrMapper);
+      return {
+        meta: {
+          pageSize: x.meta.pageSize,
+          continuationToken: x.meta.continuationToken,
+        },
+        data: x.data.map(itemFactory),
+      };
+    });
+  });
+};

package/src/mapping.ts

@@ -1,43 +1,43 @@
-type DeserializeFn<T> = (source: any, type: Type<T>) => T | null | undefined;
-export type Type<T> = { new(): T };
-export type Mapper<T> = ((source: any) => T);
-
-export function getNullableMapper<T>(deserialize: DeserializeFn<T>, typeOrMap: Type<T> | Mapper<T> | undefined): Mapper<T | null> {
-    if (!typeOrMap) {
-        return (x: any) => <T>x;
-    }
-
-    if (isZeroArgumentFunction(typeOrMap)) {
-        // It cannot be a factory function if it takes no arguments,
-        // so it must be a (zero argument) type (constructor)
-        return (x: any) => {
-            const bound = deserialize(x, typeOrMap);
-
-            // The server cannot produce the undefined result
-            if (bound === undefined) {
-                throw Error("The model factory created a undefined result");
-            }
-
-            return bound;
-        }
-    }
-
-    return typeOrMap;
-}
-
-export function getMapper<T>(deserialize: DeserializeFn<T>, typeOrMap: Type<T> | Mapper<T> | undefined): Mapper<T> {
-    const nullableFactory = getNullableMapper(deserialize, typeOrMap);
-    return (x: any) => {
-        const result = nullableFactory(x);
-
-        if (result === null) {
-            throw Error("The model factory created a null result");
-        }
-
-        return result;
-    };
-}
-
-function isZeroArgumentFunction<T>(typeCtor: Function): typeCtor is { new(): T } {
-    return typeCtor.length === 0;
+type DeserializeFn<T> = (source: any, type: Type<T>) => T | null | undefined;
+export type Type<T> = { new(): T };
+export type Mapper<T> = ((source: any) => T);
+
+export function getNullableMapper<T>(deserialize: DeserializeFn<T>, typeOrMap: Type<T> | Mapper<T> | undefined): Mapper<T | null> {
+    if (!typeOrMap) {
+        return (x: any) => <T>x;
+    }
+
+    if (isZeroArgumentFunction(typeOrMap)) {
+        // It cannot be a factory function if it takes no arguments,
+        // so it must be a (zero argument) type (constructor)
+        return (x: any) => {
+            const bound = deserialize(x, typeOrMap);
+
+            // The server cannot produce the undefined result
+            if (bound === undefined) {
+                throw Error("The model factory created a undefined result");
+            }
+
+            return bound;
+        }
+    }
+
+    return typeOrMap;
+}
+
+export function getMapper<T>(deserialize: DeserializeFn<T>, typeOrMap: Type<T> | Mapper<T> | undefined): Mapper<T> {
+    const nullableFactory = getNullableMapper(deserialize, typeOrMap);
+    return (x: any) => {
+        const result = nullableFactory(x);
+
+        if (result === null) {
+            throw Error("The model factory created a null result");
+        }
+
+        return result;
+    };
+}
+
+function isZeroArgumentFunction<T>(typeCtor: Function): typeCtor is { new(): T } {
+    return typeCtor.length === 0;
 }

package/src/msgpack.ts

@@ -1,48 +1,63 @@
-import { deserialize } from "@utiliread/msgpack";
-import { HttpBuilder } from "./http-builder";
-import { decodeArrayStream } from "@msgpack/msgpack";
-import { getMapper, Mapper, Type } from "./mapping";
-
-type TypeOrMapper<T> = Type<T> | Mapper<T>;
-
-declare module "./http-builder" {
-  interface HttpBuilder {
-    expectMessagePackArray<T>(
-      typeOrMapper?: TypeOrMapper<T>
-    ): HttpBuilderOfT<T[]>;
-    streamMessagePackArray<T>(
-      typeOrMapper?: TypeOrMapper<T>
-    ): HttpBuilderOfT<AsyncGenerator<T, void, unknown>>;
-  }
-}
-
-HttpBuilder.prototype.expectMessagePackArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-  return this.useHandler(async (response) => {
-    const items: T[] = [];
-    const itemFactory = getMapper(deserialize, typeOrMapper);
-    for await (const item of decodeArrayStream(response.body!)) {
-      items.push(itemFactory(item));
-    }
-    return items;
-  });
-};
-
-HttpBuilder.prototype.streamMessagePackArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-
-  async function* handler(response: Response) {
-    const itemFactory = getMapper(deserialize, typeOrMapper);
-    for await (const item of decodeArrayStream(response.body!)) {
-      yield itemFactory(item);
-    }
-  }
-
-  return this.useHandler((response) => Promise.resolve(handler(response)));
-};
+import { deserialize } from "@utiliread/msgpack";
+import { HttpBuilder } from "./http-builder";
+import { decodeArrayStream, decodeAsync } from "@msgpack/msgpack";
+import { getMapper, Mapper, Type } from "./mapping";
+
+type TypeOrMapper<T> = Type<T> | Mapper<T>;
+
+declare module "./http-builder" {
+  interface HttpBuilder {
+    expectMessagePack<T>(
+      typeOrMapper?: TypeOrMapper<T>
+    ): HttpBuilderOfT<T>;
+    expectMessagePackArray<T>(
+      typeOrMapper?: TypeOrMapper<T>
+    ): HttpBuilderOfT<T[]>;
+    streamMessagePackArray<T>(
+      typeOrMapper?: TypeOrMapper<T>
+    ): HttpBuilderOfT<AsyncGenerator<T, void, unknown>>;
+  }
+}
+
+HttpBuilder.prototype.expectMessagePack = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+  return this.useHandler(async (response) => {
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    const decoded = await decodeAsync(response.body!);
+    return itemFactory(decoded);
+  });
+};
+
+HttpBuilder.prototype.expectMessagePackArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+  return this.useHandler(async (response) => {
+    const items: T[] = [];
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    for await (const item of decodeArrayStream(response.body!)) {
+      items.push(itemFactory(item));
+    }
+    return items;
+  });
+};
+
+HttpBuilder.prototype.streamMessagePackArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+
+  async function* handler(response: Response) {
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    for await (const item of decodeArrayStream(response.body!)) {
+      yield itemFactory(item);
+    }
+  }
+
+  return this.useHandler((response) => Promise.resolve(handler(response)));
+};

package/src/pagination.ts

@@ -1,26 +1,26 @@
-export interface Page {
-    number: number;
-    size: number;
-}
-
-export interface PaginationResult<T> {
-    meta: {
-        pageCount: number;
-        pageSize: number;
-        totalItems: number;
-    },
-    data: T[];
-}
-
-export interface InfinitePage {
-    continuationToken?: string;
-    size: number;
-}
-
-export interface InfinitePaginationResult<T> {
-    meta: {
-        pageSize: number;
-        continuationToken: string | null;
-    },
-    data: T[];
+export interface Page {
+    number: number;
+    size: number;
+}
+
+export interface PaginationResult<T> {
+    meta: {
+        pageCount: number;
+        pageSize: number;
+        totalItems: number;
+    },
+    data: T[];
+}
+
+export interface InfinitePage {
+    continuationToken?: string;
+    size: number;
+}
+
+export interface InfinitePaginationResult<T> {
+    meta: {
+        pageSize: number;
+        continuationToken: string | null;
+    },
+    data: T[];
 }

package/src/problem-details.ts

@@ -1,8 +1,8 @@
-export interface ProblemDetails {
-    detail?: string;
-    extensions?: any;
-    instance?: string;
-    status?: number;
-    title?: string;
-    type: string;
+export interface ProblemDetails {
+    detail?: string;
+    extensions?: any;
+    instance?: string;
+    status?: number;
+    title?: string;
+    type: string;
 }

package/src/query-string.spec.ts

@@ -1,63 +1,63 @@
-import { DateTime } from 'luxon';
-import { QueryString } from './query-string';
-import { expect } from 'chai';
-
-describe("query-string", () => {
-    it("should handle string", () => {
-        const qs = QueryString.serialize({
-            aString: "hello"
-        });
-
-        expect(qs).to.equal("?aString=hello");
-    });
-
-    it("should handle string array", () => {
-        const qs = QueryString.serialize({
-            aString: ["hello","world"]
-        });
-
-        expect(qs).to.equal("?aString[0]=hello&aString[1]=world");
-    });
-
-    it("should handle object array", () => {
-        const qs = QueryString.serialize({
-            array: [{a: "hello"}, {b: "world"}]
-        });
-
-        expect(qs).to.equal("?array[0].a=hello&array[1].b=world");
-    });
-
-    it("should handle luxon DateTime in local timezone", () => {
-        const datetime = DateTime.fromObject({year: 2014, month: 11, day: 12, hour: 21, minute: 6});
-        const qs = QueryString.serialize({
-            aDateTime: datetime
-        });
-
-        expect(qs).to.equal("?aDateTime=" + encodeURIComponent("2014-11-12T21:06:00.000+01:00"));
-    });
-
-    it("should handle luxon DateTime in utc", () => {
-        const datetime = DateTime.fromObject({year: 2014, month: 11, day: 12, hour: 21, minute: 6}).toUTC();
-        const qs = QueryString.serialize({
-            aDateTime: datetime
-        });
-
-        expect(qs).to.equal("?aDateTime=" + encodeURIComponent("2014-11-12T20:06:00.000Z"));
-    });
-
-    it("should handle null", () => {
-        const qs = QueryString.serialize({
-            null: null
-        });
-
-        expect(qs).to.equal("?null");
-    });
-
-    it("should not include undefined", () => {
-        const qs = QueryString.serialize({
-            null: undefined
-        });
-
-        expect(qs).to.equal("");
-    })
+import { DateTime } from 'luxon';
+import { QueryString } from './query-string';
+import { expect } from 'chai';
+
+describe("query-string", () => {
+    it("should handle string", () => {
+        const qs = QueryString.serialize({
+            aString: "hello"
+        });
+
+        expect(qs).to.equal("?aString=hello");
+    });
+
+    it("should handle string array", () => {
+        const qs = QueryString.serialize({
+            aString: ["hello","world"]
+        });
+
+        expect(qs).to.equal("?aString[0]=hello&aString[1]=world");
+    });
+
+    it("should handle object array", () => {
+        const qs = QueryString.serialize({
+            array: [{a: "hello"}, {b: "world"}]
+        });
+
+        expect(qs).to.equal("?array[0].a=hello&array[1].b=world");
+    });
+
+    it("should handle luxon DateTime in local timezone", () => {
+        const datetime = DateTime.fromObject({year: 2014, month: 11, day: 12, hour: 21, minute: 6});
+        const qs = QueryString.serialize({
+            aDateTime: datetime
+        });
+
+        expect(qs).to.equal("?aDateTime=" + encodeURIComponent("2014-11-12T21:06:00.000+01:00"));
+    });
+
+    it("should handle luxon DateTime in utc", () => {
+        const datetime = DateTime.fromObject({year: 2014, month: 11, day: 12, hour: 21, minute: 6}).toUTC();
+        const qs = QueryString.serialize({
+            aDateTime: datetime
+        });
+
+        expect(qs).to.equal("?aDateTime=" + encodeURIComponent("2014-11-12T20:06:00.000Z"));
+    });
+
+    it("should handle null", () => {
+        const qs = QueryString.serialize({
+            null: null
+        });
+
+        expect(qs).to.equal("?null");
+    });
+
+    it("should not include undefined", () => {
+        const qs = QueryString.serialize({
+            null: undefined
+        });
+
+        expect(qs).to.equal("");
+    })
 });