@utiliread/http 1.17.7 → 1.18.0

package/plugins/json/src/index.ts

@@ -1,122 +1,124 @@
-import { HttpBuilder, HttpBuilderOfT, Mapping } from "@utiliread/http";
-import type {
-  InfinitePaginationResult,
-  PaginationResult,
-} from "@utiliread/http";
-import { deserialize, serialize } from "@utiliread/json";
-
-// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
-declare module "@utiliread/http" {
-  interface HttpBuilder {
-    withJson(content: any): this;
-
-    expectJson<T>(typeOrMapper?: Mapping.TypeOrMapper<T>): HttpBuilderOfT<T>;
-    expectJsonArray<T>(typeOrMapper: Mapping.TypeOrMapper<T>): HttpBuilderOfT<T[]>;
-    expectJsonNullableArray<T>(
-      typeOrMapper: Mapping.TypeOrMapper<T>
-    ): HttpBuilderOfT<(T | null)[]>;
-    expectJsonPaginationResult<T>(
-      typeOrMapper: Mapping.TypeOrMapper<T>
-    ): HttpBuilderOfT<PaginationResult<T>>;
-    expectJsonInfinitePaginationResult<T>(
-      typeOrMapper: Mapping.TypeOrMapper<T>
-    ): HttpBuilderOfT<InfinitePaginationResult<T>>;
-  }
-  interface HttpBuilderOfT<T> {
-    withJson(content: any): this;
-  }
-}
-
-HttpBuilder.prototype.withJson = function (this: HttpBuilder, content: any) {
-  this.message.content = serialize(content);
-  this.message.contentType = "application/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;
-};
-
-HttpBuilder.prototype.expectJson = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: Mapping.TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse
-      .json()
-      .then((x) => Mapping.getMapper(deserialize, typeOrMapper)(x));
-  });
-};
-
-HttpBuilder.prototype.expectJsonArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: Mapping.TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse.json().then((x: any[]) => {
-      const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-      return x.map(itemFactory);
-    });
-  });
-};
-
-HttpBuilder.prototype.expectJsonNullableArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: Mapping.TypeOrMapper<T>
-): HttpBuilderOfT<(T | null)[]> {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse.json().then((x: any[]) => {
-      const itemFactory = Mapping.getNullableMapper(deserialize, typeOrMapper);
-      return x.map(itemFactory);
-    });
-  });
-};
-
-HttpBuilder.prototype.expectJsonPaginationResult = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: Mapping.TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse.json().then((x: PaginationResult<any>) => {
-      const itemFactory = Mapping.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: Mapping.TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse
-      .json()
-      .then((x: InfinitePaginationResult<any>) => {
-        const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-        return {
-          meta: {
-            pageSize: x.meta.pageSize,
-            continuationToken: x.meta.continuationToken,
-          },
-          data: x.data.map(itemFactory),
-        };
-      });
-  });
-};
+import { HttpBuilder, HttpBuilderOfT, Mapping } from "@utiliread/http";
+import type {
+  InfinitePaginationResult,
+  PaginationResult,
+} from "@utiliread/http";
+import { deserialize, serialize } from "@utiliread/json";
+
+// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
+declare module "@utiliread/http" {
+  interface HttpBuilder {
+    withJson(content: any): this;
+
+    expectJson<T>(typeOrMapper?: Mapping.TypeOrMapper<T>): HttpBuilderOfT<T>;
+    expectJsonArray<T>(
+      typeOrMapper: Mapping.TypeOrMapper<T>,
+    ): HttpBuilderOfT<T[]>;
+    expectJsonNullableArray<T>(
+      typeOrMapper: Mapping.TypeOrMapper<T>,
+    ): HttpBuilderOfT<(T | null)[]>;
+    expectJsonPaginationResult<T>(
+      typeOrMapper: Mapping.TypeOrMapper<T>,
+    ): HttpBuilderOfT<PaginationResult<T>>;
+    expectJsonInfinitePaginationResult<T>(
+      typeOrMapper: Mapping.TypeOrMapper<T>,
+    ): HttpBuilderOfT<InfinitePaginationResult<T>>;
+  }
+  interface HttpBuilderOfT<T> {
+    withJson(content: any): this;
+  }
+}
+
+HttpBuilder.prototype.withJson = function (this: HttpBuilder, content: any) {
+  this.message.content = serialize(content);
+  this.message.contentType = "application/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;
+};
+
+HttpBuilder.prototype.expectJson = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: Mapping.TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.rawResponse
+      .json()
+      .then((x) => Mapping.getMapper(deserialize, typeOrMapper)(x));
+  });
+};
+
+HttpBuilder.prototype.expectJsonArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: Mapping.TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.rawResponse.json().then((x: any[]) => {
+      const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
+      return x.map(itemFactory);
+    });
+  });
+};
+
+HttpBuilder.prototype.expectJsonNullableArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: Mapping.TypeOrMapper<T>,
+): HttpBuilderOfT<(T | null)[]> {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.rawResponse.json().then((x: any[]) => {
+      const itemFactory = Mapping.getNullableMapper(deserialize, typeOrMapper);
+      return x.map(itemFactory);
+    });
+  });
+};
+
+HttpBuilder.prototype.expectJsonPaginationResult = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: Mapping.TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.rawResponse.json().then((x: PaginationResult<any>) => {
+      const itemFactory = Mapping.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: Mapping.TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    return response.rawResponse
+      .json()
+      .then((x: InfinitePaginationResult<any>) => {
+        const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
+        return {
+          meta: {
+            pageSize: x.meta.pageSize,
+            continuationToken: x.meta.continuationToken,
+          },
+          data: x.data.map(itemFactory),
+        };
+      });
+  });
+};

package/plugins/jsonpatch/node_modules/@utiliread/http/package.json

@@ -0,0 +1,4 @@
+{
+    "name": "@utiliread/http",
+    "types": "../../../../../dist/esm/index.d.ts"
+}

package/plugins/jsonpatch/src/index.ts

@@ -1,31 +1,31 @@
-import { HttpBuilder, HttpBuilderOfT } from "@utiliread/http";
-import { serialize } from "@utiliread/json";
-import type { Operation } from "@utiliread/jsonpatch";
-
-// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
-declare module "@utiliread/http" {
-  interface HttpBuilder {
-    withJsonPatch(operations: Operation[]): this;
-  }
-  interface HttpBuilderOfT<T> {
-    withJsonPatch(operations: Operation[]): 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.withJsonPatch = function <T>(
-  this: HttpBuilderOfT<T>,
-  operations: Operation[]
-) {
-  this.message.content = serialize(operations);
-  this.message.contentType = "application/json-patch+json";
-  return this;
-};
+import { HttpBuilder, HttpBuilderOfT } from "@utiliread/http";
+import { serialize } from "@utiliread/json";
+import type { Operation } from "@utiliread/jsonpatch";
+
+// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
+declare module "@utiliread/http" {
+  interface HttpBuilder {
+    withJsonPatch(operations: Operation[]): this;
+  }
+  interface HttpBuilderOfT<T> {
+    withJsonPatch(operations: Operation[]): 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.withJsonPatch = function <T>(
+  this: HttpBuilderOfT<T>,
+  operations: Operation[],
+) {
+  this.message.content = serialize(operations);
+  this.message.contentType = "application/json-patch+json";
+  return this;
+};

package/plugins/msgpack/node_modules/@utiliread/http/package.json

@@ -0,0 +1,4 @@
+{
+    "name": "@utiliread/http",
+    "types": "../../../../../dist/esm/index.d.ts"
+}

package/plugins/msgpack/src/index.ts

@@ -1,60 +1,67 @@
-import { HttpBuilder, HttpBuilderOfT, HttpResponse, Mapping } from "@utiliread/http";
-import { decodeArrayStream, decodeAsync } from "@msgpack/msgpack";
-
-import { deserialize } from "@utiliread/msgpack";
-
-// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
-declare module "@utiliread/http" {
-  interface HttpBuilder {
-    expectMessagePack<T>(typeOrMapper?: Mapping.TypeOrMapper<T>): HttpBuilderOfT<T>;
-    expectMessagePackArray<T>(
-      typeOrMapper?: Mapping.TypeOrMapper<T>
-    ): HttpBuilderOfT<T[]>;
-    streamMessagePackArray<T>(
-      typeOrMapper?: Mapping.TypeOrMapper<T>
-    ): HttpBuilderOfT<AsyncGenerator<T, void, unknown>>;
-  }
-}
-
-HttpBuilder.prototype.expectMessagePack = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: Mapping.TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-  return this.useHandler(async (response) => {
-    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-    const decoded = await decodeAsync(response.rawResponse.body!);
-    return itemFactory(decoded);
-  });
-};
-
-HttpBuilder.prototype.expectMessagePackArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: Mapping.TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-  return this.useHandler(async (response) => {
-    const items: T[] = [];
-    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
-      items.push(itemFactory(item));
-    }
-    return items;
-  });
-};
-
-HttpBuilder.prototype.streamMessagePackArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: Mapping.TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-
-  async function* handler(response: HttpResponse) {
-    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
-      yield itemFactory(item);
-    }
-  }
-
-  return this.useHandler((response) => Promise.resolve(handler(response)));
-};
+import {
+  HttpBuilder,
+  HttpBuilderOfT,
+  HttpResponse,
+  Mapping,
+} from "@utiliread/http";
+import { decodeArrayStream, decodeAsync } from "@msgpack/msgpack";
+
+import { deserialize } from "@utiliread/msgpack";
+
+// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
+declare module "@utiliread/http" {
+  interface HttpBuilder {
+    expectMessagePack<T>(
+      typeOrMapper?: Mapping.TypeOrMapper<T>,
+    ): HttpBuilderOfT<T>;
+    expectMessagePackArray<T>(
+      typeOrMapper?: Mapping.TypeOrMapper<T>,
+    ): HttpBuilderOfT<T[]>;
+    streamMessagePackArray<T>(
+      typeOrMapper?: Mapping.TypeOrMapper<T>,
+    ): HttpBuilderOfT<AsyncGenerator<T, void, unknown>>;
+  }
+}
+
+HttpBuilder.prototype.expectMessagePack = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: Mapping.TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+  return this.useHandler(async (response) => {
+    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
+    const decoded = await decodeAsync(response.rawResponse.body!);
+    return itemFactory(decoded);
+  });
+};
+
+HttpBuilder.prototype.expectMessagePackArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: Mapping.TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+  return this.useHandler(async (response) => {
+    const items: T[] = [];
+    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
+    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
+      items.push(itemFactory(item));
+    }
+    return items;
+  });
+};
+
+HttpBuilder.prototype.streamMessagePackArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: Mapping.TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+
+  async function* handler(response: HttpResponse) {
+    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
+    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
+      yield itemFactory(item);
+    }
+  }
+
+  return this.useHandler((response) => Promise.resolve(handler(response)));
+};

package/src/event-aggregator.ts

@@ -1,32 +1,32 @@
 type Callback<P extends any[] = any[]> = (...params: P) => void | Promise<void>;
 
 export class EventAggregator<P extends any[]> {
-    private callbacks: Function[] = [];
+  private callbacks: Function[] = [];
 
-    get any() {
-        return this.callbacks.length > 0;
-    }
+  get any() {
+    return this.callbacks.length > 0;
+  }
 
-    subscribe(callback: Callback<P>): Subscription {
-        this.callbacks.push(callback);
-        return {
-            dispose: () => {
-                const index = this.callbacks.indexOf(callback);
-                if (index >= 0) {
-                    this.callbacks.splice(index, 1);
-                }
-            }
+  subscribe(callback: Callback<P>): Subscription {
+    this.callbacks.push(callback);
+    return {
+      dispose: () => {
+        const index = this.callbacks.indexOf(callback);
+        if (index >= 0) {
+          this.callbacks.splice(index, 1);
         }
-    }
+      },
+    };
+  }
 
-    async publish(...params: P) {
-        const callbacks = this.callbacks.slice();
-        for (const callback of callbacks) {
-            await Promise.resolve(callback.apply(this, params));
-        }
+  async publish(...params: P) {
+    const callbacks = this.callbacks.slice();
+    for (const callback of callbacks) {
+      await Promise.resolve(callback.apply(this, params));
     }
+  }
 }
 
 export interface Subscription {
-    dispose(): void;
-}
+  dispose(): void;
+}

package/src/events.ts

@@ -1,39 +1,39 @@
-import { HttpBuilder, HttpBuilderOfT, Message } from "./http-builder";
-import { HttpResponse } from "./http-response";
-
-interface Events {
-  sent: (response: HttpResponse, request: Message) => void | Promise<void>;
-}
-
-interface EventsOfT<T> extends Events {
-  received: (
-    response: HttpResponse,
-    request: Message,
-    value: T
-  ) => void | Promise<void>;
-}
-
-export function events<P extends any[]>(
-  action: (...params: P) => HttpBuilder,
-  configure: (...params: P) => Partial<Events>
-): (...params: P) => HttpBuilder;
-export function events<B extends HttpBuilderOfT<T>, P extends any[], T>(
-  action: (...params: P) => B,
-  configure: (...params: P) => Partial<EventsOfT<T>>
-): (...params: P) => B;
-export function events<B extends HttpBuilderOfT<T>, P extends any[], T>(
-  action: (...params: P) => B,
-  configure: (...params: P) => Partial<EventsOfT<T>>
-): (...params: P) => B {
-  return function (...params: P) {
-    const builder = action(...params);
-    const events = configure(...params);
-    if (events.sent) {
-      builder.onSent(events.sent);
-    }
-    if (builder instanceof HttpBuilderOfT && events.received) {
-      builder.onReceived(events.received);
-    }
-    return builder;
-  };
-}
+import { HttpBuilder, HttpBuilderOfT, Message } from "./http-builder";
+import { HttpResponse } from "./http-response";
+
+interface Events {
+  sent: (response: HttpResponse, request: Message) => void | Promise<void>;
+}
+
+interface EventsOfT<T> extends Events {
+  received: (
+    response: HttpResponse,
+    request: Message,
+    value: T,
+  ) => void | Promise<void>;
+}
+
+export function events<P extends any[]>(
+  action: (...params: P) => HttpBuilder,
+  configure: (...params: P) => Partial<Events>,
+): (...params: P) => HttpBuilder;
+export function events<B extends HttpBuilderOfT<T>, P extends any[], T>(
+  action: (...params: P) => B,
+  configure: (...params: P) => Partial<EventsOfT<T>>,
+): (...params: P) => B;
+export function events<B extends HttpBuilderOfT<T>, P extends any[], T>(
+  action: (...params: P) => B,
+  configure: (...params: P) => Partial<EventsOfT<T>>,
+): (...params: P) => B {
+  return function (...params: P) {
+    const builder = action(...params);
+    const events = configure(...params);
+    if (events.sent) {
+      builder.onSent(events.sent);
+    }
+    if (builder instanceof HttpBuilderOfT && events.received) {
+      builder.onReceived(events.received);
+    }
+    return builder;
+  };
+}

package/src/helpers.ts

@@ -1,14 +1,14 @@
-import { HttpError } from './http-error';
-import { TimeoutError } from './timeout-error';
+import { HttpError } from "./http-error";
+import { TimeoutError } from "./timeout-error";
 
 export function isHttpError(error: Error): error is HttpError {
-    return error.name === "HttpError";
+  return error.name === "HttpError";
 }
 
 export function isAbortError(error: Error): boolean {
-    return error.name === "AbortError";
+  return error.name === "AbortError";
 }
 
 export function isTimeoutError(error: Error): error is TimeoutError {
-    return error.name === "TimeoutError";
-}
+  return error.name === "TimeoutError";
+}