@nestia/fetcher 2.4.5 → 2.4.6

package/src/IConnection.ts

@@ -209,28 +209,28 @@ export namespace IConnection {
             ? T[P] | undefined
             : never
           : Lowercase<P> extends
-              | "age"
-              | "authorization"
-              | "content-length"
-              | "content-type"
-              | "etag"
-              | "expires"
-              | "from"
-              | "host"
-              | "if-modified-since"
-              | "if-unmodified-since"
-              | "last-modified"
-              | "location"
-              | "max-forwards"
-              | "proxy-authorization"
-              | "referer"
-              | "retry-after"
-              | "server"
-              | "user-agent"
-          ? T[P] extends Array<HeaderValue>
-            ? never
+                | "age"
+                | "authorization"
+                | "content-length"
+                | "content-type"
+                | "etag"
+                | "expires"
+                | "from"
+                | "host"
+                | "if-modified-since"
+                | "if-unmodified-since"
+                | "last-modified"
+                | "location"
+                | "max-forwards"
+                | "proxy-authorization"
+                | "referer"
+                | "retry-after"
+                | "server"
+                | "user-agent"
+            ? T[P] extends Array<HeaderValue>
+              ? never
+              : T[P] | undefined
             : T[P] | undefined
-          : T[P] | undefined
         : never
       : never;
   };

package/src/IEncryptionPassword.ts

@@ -1,50 +1,50 @@
-import { IConnection } from "./IConnection";
-
-/**
- * Encryption password.
- *
- * `IEncryptionPassword` is a type of interface who represents encryption password used by
- * the {@link Fetcher} with AES-128/256 algorithm. If your encryption password is not fixed
- * but changes according to the input content, you can utilize the
- * {@link IEncryptionPassword.Closure} function type.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export interface IEncryptionPassword {
-  /**
-   * Secret key.
-   */
-  key: string;
-
-  /**
-   * Initialization Vector.
-   */
-  iv: string;
-}
-export namespace IEncryptionPassword {
-  /**
-   * Type of a closure function returning the {@link IEncryptionPassword} object.
-   *
-   * `IEncryptionPassword.Closure` is a type of closure function who are returning the
-   * {@link IEncryptionPassword} object. It would be used when your encryption password
-   * be changed according to the input content.
-   */
-  export interface Closure {
-    /**
-     * Encryption password getter.
-     *
-     * @param props Properties for predication
-     * @returns Encryption password
-     */
-    (props: IProps): IEncryptionPassword;
-  }
-
-  /**
-   * Properties for the closure.
-   */
-  export interface IProps {
-    headers: Record<string, IConnection.HeaderValue | undefined>;
-    body: string;
-    direction: "encode" | "decode";
-  }
-}
+import { IConnection } from "./IConnection";
+
+/**
+ * Encryption password.
+ *
+ * `IEncryptionPassword` is a type of interface who represents encryption password used by
+ * the {@link Fetcher} with AES-128/256 algorithm. If your encryption password is not fixed
+ * but changes according to the input content, you can utilize the
+ * {@link IEncryptionPassword.Closure} function type.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export interface IEncryptionPassword {
+  /**
+   * Secret key.
+   */
+  key: string;
+
+  /**
+   * Initialization Vector.
+   */
+  iv: string;
+}
+export namespace IEncryptionPassword {
+  /**
+   * Type of a closure function returning the {@link IEncryptionPassword} object.
+   *
+   * `IEncryptionPassword.Closure` is a type of closure function who are returning the
+   * {@link IEncryptionPassword} object. It would be used when your encryption password
+   * be changed according to the input content.
+   */
+  export interface Closure {
+    /**
+     * Encryption password getter.
+     *
+     * @param props Properties for predication
+     * @returns Encryption password
+     */
+    (props: IProps): IEncryptionPassword;
+  }
+
+  /**
+   * Properties for the closure.
+   */
+  export interface IProps {
+    headers: Record<string, IConnection.HeaderValue | undefined>;
+    body: string;
+    direction: "encode" | "decode";
+  }
+}

package/src/IPropagation.ts

@@ -71,8 +71,8 @@ export namespace IPropagation {
     status: StatusValue extends "2XX" | "3XX" | "4XX" | "5XX"
       ? StatusRange<StatusValue>
       : StatusValue extends number
-      ? StatusValue
-      : never;
+        ? StatusValue
+        : never;
     data: Primitive<BodyData>;
     headers: Record<string, string | string[]>;
   }
@@ -83,10 +83,10 @@ export namespace IPropagation {
   export type StatusRange<T extends "2XX" | "3XX" | "4XX" | "5XX"> = T extends 0
     ? IntRange<200, 299>
     : T extends 3
-    ? IntRange<300, 399>
-    : T extends 4
-    ? IntRange<400, 499>
-    : IntRange<500, 599>;
+      ? IntRange<300, 399>
+      : T extends 4
+        ? IntRange<400, 499>
+        : IntRange<500, 599>;
 
   type IntRange<F extends number, T extends number> = Exclude<
     Enumerate<T>,

package/src/IRandomGenerator.ts

@@ -1,38 +1,38 @@
-export interface IRandomGenerator {
-  boolean(): boolean;
-  integer(minimum?: number, maximum?: number): number;
-  number(minimum?: number, maximum?: number): number;
-  bigint(minimum?: bigint, maximum?: bigint): bigint;
-  string(length?: number): string;
-  array<T>(closure: (index: number) => T, count?: number): T[];
-  length(): number;
-
-  uuid(): string;
-  email(): string;
-  url(): string;
-  ipv4(): string;
-  ipv6(): string;
-  pattern(regex: RegExp): string;
-  date(minimum?: number, maximum?: number): string;
-  datetime(minimum?: number, maximum?: number): string;
-
-  customs?: IRandomGenerator.CustomMap;
-}
-export namespace IRandomGenerator {
-  export type CustomMap = {
-    [Type in keyof Customizable]?: (
-      tags: ICommentTag[],
-    ) => Customizable[Type] | undefined;
-  };
-
-  export type Customizable = {
-    number: number;
-    string: string;
-    bigint: bigint;
-  };
-
-  export interface ICommentTag {
-    name: string;
-    value?: string;
-  }
-}
+export interface IRandomGenerator {
+  boolean(): boolean;
+  integer(minimum?: number, maximum?: number): number;
+  number(minimum?: number, maximum?: number): number;
+  bigint(minimum?: bigint, maximum?: bigint): bigint;
+  string(length?: number): string;
+  array<T>(closure: (index: number) => T, count?: number): T[];
+  length(): number;
+
+  uuid(): string;
+  email(): string;
+  url(): string;
+  ipv4(): string;
+  ipv6(): string;
+  pattern(regex: RegExp): string;
+  date(minimum?: number, maximum?: number): string;
+  datetime(minimum?: number, maximum?: number): string;
+
+  customs?: IRandomGenerator.CustomMap;
+}
+export namespace IRandomGenerator {
+  export type CustomMap = {
+    [Type in keyof Customizable]?: (
+      tags: ICommentTag[],
+    ) => Customizable[Type] | undefined;
+  };
+
+  export type Customizable = {
+    number: number;
+    string: string;
+    bigint: bigint;
+  };
+
+  export interface ICommentTag {
+    name: string;
+    value?: string;
+  }
+}

package/src/PlainFetcher.ts

@@ -1,106 +1,106 @@
-import { IConnection } from "./IConnection";
-import { IPropagation } from "./IPropagation";
-import { Primitive } from "./Primitive";
-import { FetcherBase } from "./internal/FetcherBase";
-import { IFetchRoute } from "./internal/IFetchRoute";
-
-/**
- * Utility class for `fetch` functions used in `@nestia/sdk`.
- *
- * `PlainFetcher` is a utility class designed for SDK functions generated by
- * [`@nestia/sdk`](https://nestia.io/docs/sdk/sdk), interacting with the remote
- * HTTP sever API. In other words, this is a collection of dedicated `fetch()`
- * functions for `@nestia/sdk`.
- *
- * For reference, `PlainFetcher` class does not encrypt or decrypt the body data
- * at all. It just delivers plain data without any post processing. If you've
- * defined a controller method through `@EncryptedRoute` or `@EncryptedBody`
- * decorator, then {@liink EncryptedFetcher} class would be used instead.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace PlainFetcher {
-  /**
-   * Fetch function only for `HEAD` method.
-   *
-   * @param connection Connection information for the remote HTTP server
-   * @param route Route information about the target API
-   * @return Nothing because of `HEAD` method
-   */
-  export function fetch(
-    connection: IConnection,
-    route: IFetchRoute<"HEAD">,
-  ): Promise<void>;
-
-  /**
-   * Fetch function only for `GET` method.
-   *
-   * @param connection Connection information for the remote HTTP server
-   * @param route Route information about the target API
-   * @return Response body data from the remote API
-   */
-  export function fetch<Output>(
-    connection: IConnection,
-    route: IFetchRoute<"GET">,
-  ): Promise<Primitive<Output>>;
-
-  /**
-   * Fetch function for the `POST`, `PUT`, `PATCH` and `DELETE` methods.
-   *
-   * @param connection Connection information for the remote HTTP server
-   * @param route Route information about the target API
-   * @return Response body data from the remote API
-   */
-  export function fetch<Input, Output>(
-    connection: IConnection,
-    route: IFetchRoute<"POST" | "PUT" | "PATCH" | "DELETE">,
-    input?: Input,
-    stringify?: (input: Input) => string,
-  ): Promise<Primitive<Output>>;
-
-  export async function fetch<Input, Output>(
-    connection: IConnection,
-    route: IFetchRoute<"DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT">,
-    input?: Input,
-    stringify?: (input: Input) => string,
-  ): Promise<Primitive<Output>> {
-    if (route.request?.encrypted === true || route.response?.encrypted === true)
-      throw new Error(
-        "Error on PlainFetcher.fetch(): PlainFetcher doesn't have encryption ability. Use EncryptedFetcher instead.",
-      );
-    return FetcherBase.fetch({
-      className: "PlainFetcher",
-      encode: (input) => input,
-      decode: (input) => input,
-    })(connection, route, input, stringify);
-  }
-
-  export function propagate<Output extends IPropagation<any, any>>(
-    connection: IConnection,
-    route: IFetchRoute<"GET" | "HEAD">,
-  ): Promise<Output>;
-
-  export function propagate<Input, Output extends IPropagation<any, any>>(
-    connection: IConnection,
-    route: IFetchRoute<"DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT">,
-    input?: Input,
-    stringify?: (input: Input) => string,
-  ): Promise<Output>;
-
-  export async function propagate<Input, Output extends IPropagation<any, any>>(
-    connection: IConnection,
-    route: IFetchRoute<"DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT">,
-    input?: Input,
-    stringify?: (input: Input) => string,
-  ): Promise<Output> {
-    if (route.request?.encrypted === true || route.response?.encrypted === true)
-      throw new Error(
-        "Error on PlainFetcher.propagate(): PlainFetcher doesn't have encryption ability. Use EncryptedFetcher instead.",
-      );
-    return FetcherBase.propagate({
-      className: "PlainFetcher",
-      encode: (input) => input,
-      decode: (input) => input,
-    })(connection, route, input, stringify) as Promise<Output>;
-  }
-}
+import { IConnection } from "./IConnection";
+import { IPropagation } from "./IPropagation";
+import { Primitive } from "./Primitive";
+import { FetcherBase } from "./internal/FetcherBase";
+import { IFetchRoute } from "./internal/IFetchRoute";
+
+/**
+ * Utility class for `fetch` functions used in `@nestia/sdk`.
+ *
+ * `PlainFetcher` is a utility class designed for SDK functions generated by
+ * [`@nestia/sdk`](https://nestia.io/docs/sdk/sdk), interacting with the remote
+ * HTTP sever API. In other words, this is a collection of dedicated `fetch()`
+ * functions for `@nestia/sdk`.
+ *
+ * For reference, `PlainFetcher` class does not encrypt or decrypt the body data
+ * at all. It just delivers plain data without any post processing. If you've
+ * defined a controller method through `@EncryptedRoute` or `@EncryptedBody`
+ * decorator, then {@liink EncryptedFetcher} class would be used instead.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace PlainFetcher {
+  /**
+   * Fetch function only for `HEAD` method.
+   *
+   * @param connection Connection information for the remote HTTP server
+   * @param route Route information about the target API
+   * @return Nothing because of `HEAD` method
+   */
+  export function fetch(
+    connection: IConnection,
+    route: IFetchRoute<"HEAD">,
+  ): Promise<void>;
+
+  /**
+   * Fetch function only for `GET` method.
+   *
+   * @param connection Connection information for the remote HTTP server
+   * @param route Route information about the target API
+   * @return Response body data from the remote API
+   */
+  export function fetch<Output>(
+    connection: IConnection,
+    route: IFetchRoute<"GET">,
+  ): Promise<Primitive<Output>>;
+
+  /**
+   * Fetch function for the `POST`, `PUT`, `PATCH` and `DELETE` methods.
+   *
+   * @param connection Connection information for the remote HTTP server
+   * @param route Route information about the target API
+   * @return Response body data from the remote API
+   */
+  export function fetch<Input, Output>(
+    connection: IConnection,
+    route: IFetchRoute<"POST" | "PUT" | "PATCH" | "DELETE">,
+    input?: Input,
+    stringify?: (input: Input) => string,
+  ): Promise<Primitive<Output>>;
+
+  export async function fetch<Input, Output>(
+    connection: IConnection,
+    route: IFetchRoute<"DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT">,
+    input?: Input,
+    stringify?: (input: Input) => string,
+  ): Promise<Primitive<Output>> {
+    if (route.request?.encrypted === true || route.response?.encrypted === true)
+      throw new Error(
+        "Error on PlainFetcher.fetch(): PlainFetcher doesn't have encryption ability. Use EncryptedFetcher instead.",
+      );
+    return FetcherBase.fetch({
+      className: "PlainFetcher",
+      encode: (input) => input,
+      decode: (input) => input,
+    })(connection, route, input, stringify);
+  }
+
+  export function propagate<Output extends IPropagation<any, any>>(
+    connection: IConnection,
+    route: IFetchRoute<"GET" | "HEAD">,
+  ): Promise<Output>;
+
+  export function propagate<Input, Output extends IPropagation<any, any>>(
+    connection: IConnection,
+    route: IFetchRoute<"DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT">,
+    input?: Input,
+    stringify?: (input: Input) => string,
+  ): Promise<Output>;
+
+  export async function propagate<Input, Output extends IPropagation<any, any>>(
+    connection: IConnection,
+    route: IFetchRoute<"DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT">,
+    input?: Input,
+    stringify?: (input: Input) => string,
+  ): Promise<Output> {
+    if (route.request?.encrypted === true || route.response?.encrypted === true)
+      throw new Error(
+        "Error on PlainFetcher.propagate(): PlainFetcher doesn't have encryption ability. Use EncryptedFetcher instead.",
+      );
+    return FetcherBase.propagate({
+      className: "PlainFetcher",
+      encode: (input) => input,
+      decode: (input) => input,
+    })(connection, route, input, stringify) as Promise<Output>;
+  }
+}

package/src/Primitive.ts

@@ -32,61 +32,62 @@
  * @author Kyungsu Kang - https://github.com/kakasoo
  * @author Michael - https://github.com/8471919
  */
-export type Primitive<T> = Equal<T, PrimitiveMain<T>> extends true
-  ? T
-  : PrimitiveMain<T>;
+export type Primitive<T> =
+  Equal<T, PrimitiveMain<T>> extends true ? T : PrimitiveMain<T>;
 
 type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
 
 type PrimitiveMain<Instance> = Instance extends [never]
   ? never // (special trick for jsonable | null) type
   : ValueOf<Instance> extends bigint
-  ? never
-  : ValueOf<Instance> extends boolean | number | string
-  ? ValueOf<Instance>
-  : Instance extends Function
-  ? never
-  : ValueOf<Instance> extends object
-  ? Instance extends object
-    ? Instance extends NativeClass
-      ? never
-      : Instance extends IJsonable<infer Raw>
-      ? ValueOf<Raw> extends object
-        ? Raw extends object
-          ? PrimitiveObject<Raw> // object would be primitified
-          : never // cannot be
-        : ValueOf<Raw> // atomic value
-      : PrimitiveObject<Instance> // object would be primitified
-    : never // cannot be
-  : ValueOf<Instance>;
+    ? never
+    : ValueOf<Instance> extends boolean | number | string
+      ? ValueOf<Instance>
+      : Instance extends Function
+        ? never
+        : ValueOf<Instance> extends object
+          ? Instance extends object
+            ? Instance extends NativeClass
+              ? never
+              : Instance extends IJsonable<infer Raw>
+                ? ValueOf<Raw> extends object
+                  ? Raw extends object
+                    ? PrimitiveObject<Raw> // object would be primitified
+                    : never // cannot be
+                  : ValueOf<Raw> // atomic value
+                : PrimitiveObject<Instance> // object would be primitified
+            : never // cannot be
+          : ValueOf<Instance>;
 
-type PrimitiveObject<Instance extends object> = Instance extends Array<infer T>
-  ? IsTuple<Instance> extends true
-    ? PrimitiveTuple<Instance>
-    : PrimitiveMain<T>[]
-  : {
-      [P in keyof Instance]: PrimitiveMain<Instance[P]>;
-    };
+type PrimitiveObject<Instance extends object> =
+  Instance extends Array<infer T>
+    ? IsTuple<Instance> extends true
+      ? PrimitiveTuple<Instance>
+      : PrimitiveMain<T>[]
+    : {
+        [P in keyof Instance]: PrimitiveMain<Instance[P]>;
+      };
 
 type PrimitiveTuple<T extends readonly any[]> = T extends []
   ? []
   : T extends [infer F]
-  ? [PrimitiveMain<F>]
-  : T extends [infer F, ...infer Rest extends readonly any[]]
-  ? [PrimitiveMain<F>, ...PrimitiveTuple<Rest>]
-  : T extends [(infer F)?]
-  ? [PrimitiveMain<F>?]
-  : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-  ? [PrimitiveMain<F>?, ...PrimitiveTuple<Rest>]
-  : [];
+    ? [PrimitiveMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+      ? [PrimitiveMain<F>, ...PrimitiveTuple<Rest>]
+      : T extends [(infer F)?]
+        ? [PrimitiveMain<F>?]
+        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+          ? [PrimitiveMain<F>?, ...PrimitiveTuple<Rest>]
+          : [];
 
-type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
-  ? boolean
-  : IsValueOf<Instance, Number> extends true
-  ? number
-  : IsValueOf<Instance, String> extends true
-  ? string
-  : Instance;
+type ValueOf<Instance> =
+  IsValueOf<Instance, Boolean> extends true
+    ? boolean
+    : IsValueOf<Instance, Number> extends true
+      ? number
+      : IsValueOf<Instance, String> extends true
+        ? string
+        : Instance;
 
 type NativeClass =
   | Set<any>
@@ -113,10 +114,10 @@ type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
 ]
   ? false
   : T extends readonly any[]
-  ? number extends T["length"]
-    ? false
-    : true
-  : false;
+    ? number extends T["length"]
+      ? false
+      : true
+    : false;
 
 type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
   ? Object extends IValueOf<infer U>