@nestia/fetcher 9.0.0-dev.20251107-3 → 9.0.1

package/src/MigrateFetcher.ts

@@ -1,118 +1,118 @@
-import { IHttpMigrateRoute } from "@samchon/openapi";
-
-import { IConnection } from "./IConnection";
-import { IPropagation } from "./IPropagation";
-import { PlainFetcher } from "./PlainFetcher";
-
-/**
- * Use `HttpMigration.execute()` function of `@samchon/openapi` instead.
- *
- * This module would be removed in the next major update.
- *
- * @deprecated
- */
-export namespace MigrateFetcher {
-  export interface IProps {
-    route: IHttpMigrateRoute;
-    connection: IConnection;
-    arguments: any[];
-  }
-
-  export async function request(props: IProps): Promise<any> {
-    const length: number =
-      props.route.parameters.length +
-      (props.route.query ? 1 : 0) +
-      (props.route.body ? 1 : 0);
-    if (props.arguments.length !== length)
-      throw new Error(
-        `Error on MigrateFetcher.request(): arguments length is not matched with the route (expected: ${length}, actual: ${props.arguments.length}).`,
-      );
-    else if (
-      props.route.body?.["x-nestia-encrypted"] === true ||
-      props.route.success?.["x-nestia-encrypted"] === true
-    )
-      throw new Error(
-        `Error on MigrateFetcher.request(): encrypted API is not supported yet.`,
-      );
-    return PlainFetcher.fetch(
-      props.connection,
-      {
-        method: props.route.method.toUpperCase() as "POST",
-        path: getPath(props),
-        template: props.route.path,
-        status: null,
-        request: props.route.body
-          ? {
-              encrypted: false,
-              type: props.route.body.type,
-            }
-          : null,
-        response: {
-          encrypted: false,
-          type: props.route.success?.type ?? "application/json",
-        },
-      },
-      props.route.body ? props.arguments.at(-1) : undefined,
-    );
-  }
-
-  export async function propagate(
-    props: IProps,
-  ): Promise<IPropagation.IBranch<boolean, number, any>> {
-    const length: number =
-      props.route.parameters.length +
-      (props.route.query ? 1 : 0) +
-      (props.route.body ? 1 : 0);
-    if (props.arguments.length !== length)
-      throw new Error(
-        `Error on MigrateFetcher.propagate(): arguments length is not matched with the route (expected: ${length}, actual: ${props.arguments.length}).`,
-      );
-    else if (
-      props.route.body?.["x-nestia-encrypted"] === true ||
-      props.route.success?.["x-nestia-encrypted"] === true
-    )
-      throw new Error(
-        `Error on MigrateFetcher.propagate(): encrypted API is not supported yet.`,
-      );
-    return PlainFetcher.propagate(
-      props.connection,
-      {
-        method: props.route.method.toUpperCase() as "POST",
-        path: getPath(props),
-        template: props.route.path,
-        status: null,
-        request: props.route.body
-          ? {
-              encrypted: false,
-              type: props.route.body.type,
-            }
-          : null,
-        response: {
-          encrypted: false,
-          type: props.route.success?.type ?? "application/json",
-        },
-      },
-      props.route.body ? props.arguments.at(-1) : undefined,
-    ) as Promise<IPropagation.IBranch<boolean, number, any>>;
-  }
-
-  function getPath(props: Pick<IProps, "arguments" | "route">): string {
-    let path: string = props.route.emendedPath;
-    props.route.parameters.forEach((p, i) => {
-      path = path.replace(`:${p.key}`, props.arguments[i]);
-    });
-    if (props.route.query)
-      path += getQueryPath(props.arguments[props.route.parameters.length]);
-    return path;
-  }
-
-  function getQueryPath(query: Record<string, any>): string {
-    const variables = new URLSearchParams();
-    for (const [key, value] of Object.entries(query))
-      if (undefined === value) continue;
-      else if (Array.isArray(value))
-        value.forEach((elem: any) => variables.append(key, String(elem)));
-      else variables.set(key, String(value));
-    return 0 === variables.size ? "" : `?${variables.toString()}`;
-  }
-}
+import { IHttpMigrateRoute } from "@samchon/openapi";
+
+import { IConnection } from "./IConnection";
+import { IPropagation } from "./IPropagation";
+import { PlainFetcher } from "./PlainFetcher";
+
+/**
+ * Use `HttpMigration.execute()` function of `@samchon/openapi` instead.
+ *
+ * This module would be removed in the next major update.
+ *
+ * @deprecated
+ */
+export namespace MigrateFetcher {
+  export interface IProps {
+    route: IHttpMigrateRoute;
+    connection: IConnection;
+    arguments: any[];
+  }
+
+  export async function request(props: IProps): Promise<any> {
+    const length: number =
+      props.route.parameters.length +
+      (props.route.query ? 1 : 0) +
+      (props.route.body ? 1 : 0);
+    if (props.arguments.length !== length)
+      throw new Error(
+        `Error on MigrateFetcher.request(): arguments length is not matched with the route (expected: ${length}, actual: ${props.arguments.length}).`,
+      );
+    else if (
+      props.route.body?.["x-nestia-encrypted"] === true ||
+      props.route.success?.["x-nestia-encrypted"] === true
+    )
+      throw new Error(
+        `Error on MigrateFetcher.request(): encrypted API is not supported yet.`,
+      );
+    return PlainFetcher.fetch(
+      props.connection,
+      {
+        method: props.route.method.toUpperCase() as "POST",
+        path: getPath(props),
+        template: props.route.path,
+        status: null,
+        request: props.route.body
+          ? {
+              encrypted: false,
+              type: props.route.body.type,
+            }
+          : null,
+        response: {
+          encrypted: false,
+          type: props.route.success?.type ?? "application/json",
+        },
+      },
+      props.route.body ? props.arguments.at(-1) : undefined,
+    );
+  }
+
+  export async function propagate(
+    props: IProps,
+  ): Promise<IPropagation.IBranch<boolean, number, any>> {
+    const length: number =
+      props.route.parameters.length +
+      (props.route.query ? 1 : 0) +
+      (props.route.body ? 1 : 0);
+    if (props.arguments.length !== length)
+      throw new Error(
+        `Error on MigrateFetcher.propagate(): arguments length is not matched with the route (expected: ${length}, actual: ${props.arguments.length}).`,
+      );
+    else if (
+      props.route.body?.["x-nestia-encrypted"] === true ||
+      props.route.success?.["x-nestia-encrypted"] === true
+    )
+      throw new Error(
+        `Error on MigrateFetcher.propagate(): encrypted API is not supported yet.`,
+      );
+    return PlainFetcher.propagate(
+      props.connection,
+      {
+        method: props.route.method.toUpperCase() as "POST",
+        path: getPath(props),
+        template: props.route.path,
+        status: null,
+        request: props.route.body
+          ? {
+              encrypted: false,
+              type: props.route.body.type,
+            }
+          : null,
+        response: {
+          encrypted: false,
+          type: props.route.success?.type ?? "application/json",
+        },
+      },
+      props.route.body ? props.arguments.at(-1) : undefined,
+    ) as Promise<IPropagation.IBranch<boolean, number, any>>;
+  }
+
+  function getPath(props: Pick<IProps, "arguments" | "route">): string {
+    let path: string = props.route.emendedPath;
+    props.route.parameters.forEach((p, i) => {
+      path = path.replace(`:${p.key}`, props.arguments[i]);
+    });
+    if (props.route.query)
+      path += getQueryPath(props.arguments[props.route.parameters.length]);
+    return path;
+  }
+
+  function getQueryPath(query: Record<string, any>): string {
+    const variables = new URLSearchParams();
+    for (const [key, value] of Object.entries(query))
+      if (undefined === value) continue;
+      else if (Array.isArray(value))
+        value.forEach((elem: any) => variables.append(key, String(elem)));
+      else variables.set(key, String(value));
+    return 0 === variables.size ? "" : `?${variables.toString()}`;
+  }
+}

package/src/NestiaSimulator.ts

@@ -1,82 +1,82 @@
-import { HttpError } from "./HttpError";
-
-export namespace NestiaSimulator {
-  export interface IProps {
-    host: string;
-    path: string;
-    method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
-    contentType: string;
-  }
-
-  export const assert = (props: IProps) => {
-    return {
-      param: param(props),
-      query: query(props),
-      body: body(props),
-    };
-  };
-  const param =
-    (props: IProps) =>
-    (name: string) =>
-    <T>(task: () => T): void => {
-      validate((exp) => `URL parameter "${name}" is not ${exp.expected} type.`)(
-        props,
-      )(task);
-    };
-
-  const query =
-    (props: IProps) =>
-    <T>(task: () => T): void =>
-      validate(
-        () => "Request query parameters are not following the promised type.",
-      )(props)(task);
-
-  const body =
-    (props: IProps) =>
-    <T>(task: () => T): void =>
-      validate(() => "Request body is not following the promised type.")(props)(
-        task,
-      );
-
-  const validate =
-    (message: (exp: TypeGuardError) => string, path?: string) =>
-    (props: IProps) =>
-    <T>(task: () => T): void => {
-      try {
-        task();
-      } catch (exp) {
-        if (isTypeGuardError(exp))
-          throw new HttpError(
-            props.method,
-            props.host + props.path,
-            400,
-            {
-              "Content-Type": props.contentType,
-            },
-            JSON.stringify({
-              method: exp.method,
-              path: path ?? exp.path,
-              expected: exp.expected,
-              value: exp.value,
-              message: message(exp),
-            }),
-          );
-        throw exp;
-      }
-    };
-}
-
-const isTypeGuardError = (input: any): input is TypeGuardError =>
-  "string" === typeof input.method &&
-  (undefined === input.path || "string" === typeof input.path) &&
-  "string" === typeof input.expected &&
-  "string" === typeof input.name &&
-  "string" === typeof input.message &&
-  (undefined === input.stack || "string" === typeof input.stack);
-
-interface TypeGuardError extends Error {
-  method: string;
-  path: string | undefined;
-  expected: string;
-  value: any;
-}
+import { HttpError } from "./HttpError";
+
+export namespace NestiaSimulator {
+  export interface IProps {
+    host: string;
+    path: string;
+    method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+    contentType: string;
+  }
+
+  export const assert = (props: IProps) => {
+    return {
+      param: param(props),
+      query: query(props),
+      body: body(props),
+    };
+  };
+  const param =
+    (props: IProps) =>
+    (name: string) =>
+    <T>(task: () => T): void => {
+      validate((exp) => `URL parameter "${name}" is not ${exp.expected} type.`)(
+        props,
+      )(task);
+    };
+
+  const query =
+    (props: IProps) =>
+    <T>(task: () => T): void =>
+      validate(
+        () => "Request query parameters are not following the promised type.",
+      )(props)(task);
+
+  const body =
+    (props: IProps) =>
+    <T>(task: () => T): void =>
+      validate(() => "Request body is not following the promised type.")(props)(
+        task,
+      );
+
+  const validate =
+    (message: (exp: TypeGuardError) => string, path?: string) =>
+    (props: IProps) =>
+    <T>(task: () => T): void => {
+      try {
+        task();
+      } catch (exp) {
+        if (isTypeGuardError(exp))
+          throw new HttpError(
+            props.method,
+            props.host + props.path,
+            400,
+            {
+              "Content-Type": props.contentType,
+            },
+            JSON.stringify({
+              method: exp.method,
+              path: path ?? exp.path,
+              expected: exp.expected,
+              value: exp.value,
+              message: message(exp),
+            }),
+          );
+        throw exp;
+      }
+    };
+}
+
+const isTypeGuardError = (input: any): input is TypeGuardError =>
+  "string" === typeof input.method &&
+  (undefined === input.path || "string" === typeof input.path) &&
+  "string" === typeof input.expected &&
+  "string" === typeof input.name &&
+  "string" === typeof input.message &&
+  (undefined === input.stack || "string" === typeof input.stack);
+
+interface TypeGuardError extends Error {
+  method: string;
+  path: string | undefined;
+  expected: string;
+  value: any;
+}

package/src/PlainFetcher.ts

@@ -1,105 +1,105 @@
-import { IConnection } from "./IConnection";
-import { IFetchRoute } from "./IFetchRoute";
-import { IPropagation } from "./IPropagation";
-import { FetcherBase } from "./internal/FetcherBase";
-
-/**
- * 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
-   * @returns 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
-   * @returns Response body data from the remote API
-   */
-  export function fetch<Output>(
-    connection: IConnection,
-    route: IFetchRoute<"GET">,
-  ): Promise<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
-   * @returns 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<Output>;
-
-  export async function fetch<Input, Output>(
-    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.fetch(): PlainFetcher doesn't have encryption ability. Use EncryptedFetcher instead.",
-      );
-    return FetcherBase.request({
-      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 { IFetchRoute } from "./IFetchRoute";
+import { IPropagation } from "./IPropagation";
+import { FetcherBase } from "./internal/FetcherBase";
+
+/**
+ * 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
+   * @returns 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
+   * @returns Response body data from the remote API
+   */
+  export function fetch<Output>(
+    connection: IConnection,
+    route: IFetchRoute<"GET">,
+  ): Promise<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
+   * @returns 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<Output>;
+
+  export async function fetch<Input, Output>(
+    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.fetch(): PlainFetcher doesn't have encryption ability. Use EncryptedFetcher instead.",
+      );
+    return FetcherBase.request({
+      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/index.ts

@@ -1,7 +1,7 @@
-export * from "./FormDataInput";
-export * from "./HttpError";
-export * from "./IConnection";
-export * from "./IEncryptionPassword";
-export * from "./IFetchEvent";
-export * from "./IFetchRoute";
-export * from "./IPropagation";
+export * from "./FormDataInput";
+export * from "./HttpError";
+export * from "./IConnection";
+export * from "./IEncryptionPassword";
+export * from "./IFetchEvent";
+export * from "./IFetchRoute";
+export * from "./IPropagation";