@nestia/core 12.0.0-dev.20260521.6 → 12.0.0-dev.20260612.1

package/src/utils/ExceptionManager.ts

@@ -1,115 +1,115 @@
-import { HttpError } from "@nestia/fetcher";
-import { HttpException } from "@nestjs/common";
-
-import { Creator } from "../typings/Creator";
-
-/**
- * Exception manager for HTTP server.
- *
- * `ExceptionManager` is an utility class who can insert or erase custom error
- * class with its conversion method to a regular {@link nest.HttpException}
- * instance.
- *
- * If you define an API function through {@link TypedRoute} or
- * {@link EncryptedRoute} instead of the basic router decorator functions like
- * {@link nest.Get} or {@link nest.Post} and the API function throws a custom
- * error whose class has been {@link ExceptionManager.insert inserted} in this
- * `EntityManager`, the error would be automatically converted to the regular
- * {@link nest.HttpException} instance by the {@link ExceptionManager.Closure}
- * function.
- *
- * Therefore, with this `ExceptionManager` and {@link TypedRoute} or
- * {@link EncryptedRoute}, you can manage your custom error classes much
- * systemtically. You can avoid 500 internal server error or hard coding
- * implementation about the custom error classes.
- *
- * Below error classes are defaultly configured in this `ExceptionManager`
- *
- * - `typia.TypeGuardError`
- * - `@nestia/fetcher.HttpError`
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace ExceptionManager {
-  /**
-   * Insert an error class with converter.
-   *
-   * If you've inserted an duplicated error class, the closure would be
-   * overwritten.
-   *
-   * @param creator Target error class
-   * @param closure A closure function converting to the `HttpException` class
-   */
-  export function insert<T extends Error>(
-    creator: Creator<T>,
-    closure: Closure<T>,
-  ): void {
-    const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
-    if (index !== -1) tuples.splice(index, 1);
-
-    tuples.push([creator, closure]);
-    tuples.sort(([x], [y]) => (x.prototype instanceof y ? -1 : 1));
-  }
-
-  /**
-   * Erase an error class.
-   *
-   * @param creator Target error class
-   * @returns Whether be erased or not
-   */
-  export function erase<T extends Error>(creator: Creator<T>): boolean {
-    const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
-    if (index === -1) return false;
-
-    tuples.splice(index, 1);
-    return true;
-  }
-
-  export function on(closure: (error: any) => any): void {
-    listeners.add(closure);
-  }
-
-  export function off(closure: (error: any) => any): void {
-    listeners.delete(closure);
-  }
-
-  /**
-   * Type of a closure function converting to the regular
-   * {@link nest.HttpException}.
-   *
-   * `ExceptionManager.Closure` is a type of closure function who are converting
-   * from custom error to the regular {@link nest.HttpException} instance. It
-   * would be used in the {@link ExceptionManager} with {@link TypedRoute} or
-   * {@link EncryptedRoute}.
-   */
-  export interface Closure<T extends Error> {
-    /**
-     * Error converter.
-     *
-     * Convert from custom error to the regular {@link nest.HttpException}
-     * instance.
-     *
-     * @param exception Custom error instance
-     * @returns Regular {@link nest.HttpException} instance
-     */
-    (exception: T): HttpException;
-  }
-
-  /** @internal */
-  export const tuples: Array<[Creator<any>, Closure<any>]> = [];
-
-  /** @internal */
-  export const listeners: Set<(error: any) => any> = new Set();
-}
-
-ExceptionManager.insert(
-  HttpError,
-  (error) =>
-    new HttpException(
-      {
-        path: error.path,
-        message: error.message,
-      },
-      error.status,
-    ),
-);
+import { HttpError } from "@nestia/fetcher";
+import { HttpException } from "@nestjs/common";
+
+import { Creator } from "../typings/Creator";
+
+/**
+ * Exception manager for HTTP server.
+ *
+ * `ExceptionManager` is an utility class who can insert or erase custom error
+ * class with its conversion method to a regular {@link nest.HttpException}
+ * instance.
+ *
+ * If you define an API function through {@link TypedRoute} or
+ * {@link EncryptedRoute} instead of the basic router decorator functions like
+ * {@link nest.Get} or {@link nest.Post} and the API function throws a custom
+ * error whose class has been {@link ExceptionManager.insert inserted} in this
+ * `EntityManager`, the error would be automatically converted to the regular
+ * {@link nest.HttpException} instance by the {@link ExceptionManager.Closure}
+ * function.
+ *
+ * Therefore, with this `ExceptionManager` and {@link TypedRoute} or
+ * {@link EncryptedRoute}, you can manage your custom error classes much
+ * systemtically. You can avoid 500 internal server error or hard coding
+ * implementation about the custom error classes.
+ *
+ * Below error classes are defaultly configured in this `ExceptionManager`
+ *
+ * - `typia.TypeGuardError`
+ * - `@nestia/fetcher.HttpError`
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace ExceptionManager {
+  /**
+   * Insert an error class with converter.
+   *
+   * If you've inserted an duplicated error class, the closure would be
+   * overwritten.
+   *
+   * @param creator Target error class
+   * @param closure A closure function converting to the `HttpException` class
+   */
+  export function insert<T extends Error>(
+    creator: Creator<T>,
+    closure: Closure<T>,
+  ): void {
+    const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
+    if (index !== -1) tuples.splice(index, 1);
+
+    tuples.push([creator, closure]);
+    tuples.sort(([x], [y]) => (x.prototype instanceof y ? -1 : 1));
+  }
+
+  /**
+   * Erase an error class.
+   *
+   * @param creator Target error class
+   * @returns Whether be erased or not
+   */
+  export function erase<T extends Error>(creator: Creator<T>): boolean {
+    const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
+    if (index === -1) return false;
+
+    tuples.splice(index, 1);
+    return true;
+  }
+
+  export function on(closure: (error: any) => any): void {
+    listeners.add(closure);
+  }
+
+  export function off(closure: (error: any) => any): void {
+    listeners.delete(closure);
+  }
+
+  /**
+   * Type of a closure function converting to the regular
+   * {@link nest.HttpException}.
+   *
+   * `ExceptionManager.Closure` is a type of closure function who are converting
+   * from custom error to the regular {@link nest.HttpException} instance. It
+   * would be used in the {@link ExceptionManager} with {@link TypedRoute} or
+   * {@link EncryptedRoute}.
+   */
+  export interface Closure<T extends Error> {
+    /**
+     * Error converter.
+     *
+     * Convert from custom error to the regular {@link nest.HttpException}
+     * instance.
+     *
+     * @param exception Custom error instance
+     * @returns Regular {@link nest.HttpException} instance
+     */
+    (exception: T): HttpException;
+  }
+
+  /** @internal */
+  export const tuples: Array<[Creator<any>, Closure<any>]> = [];
+
+  /** @internal */
+  export const listeners: Set<(error: any) => any> = new Set();
+}
+
+ExceptionManager.insert(
+  HttpError,
+  (error) =>
+    new HttpException(
+      {
+        path: error.path,
+        message: error.message,
+      },
+      error.status,
+    ),
+);

package/src/utils/Singleton.ts

@@ -1,16 +1,16 @@
-/** @internal */
-export class Singleton<T> {
-  private value_: T | object;
-
-  public constructor(private readonly closure_: () => T) {
-    this.value_ = NOT_MOUNTED_YET;
-  }
-
-  public get(): T {
-    if (this.value_ === NOT_MOUNTED_YET) this.value_ = this.closure_();
-    return this.value_ as T;
-  }
-}
-
-/** @internal */
-const NOT_MOUNTED_YET = {};
+/** @internal */
+export class Singleton<T> {
+  private value_: T | object;
+
+  public constructor(private readonly closure_: () => T) {
+    this.value_ = NOT_MOUNTED_YET;
+  }
+
+  public get(): T {
+    if (this.value_ === NOT_MOUNTED_YET) this.value_ = this.closure_();
+    return this.value_ as T;
+  }
+}
+
+/** @internal */
+const NOT_MOUNTED_YET = {};

package/src/utils/SourceFinder.ts

@@ -1,54 +1,54 @@
-import fs from "fs";
-import { glob } from "glob";
-import path from "path";
-
-export namespace SourceFinder {
-  export const find = async (props: IProps): Promise<string[]> => {
-    const dict: Set<string> = new Set();
-
-    await emplace(props.filter)(props.include)((str) => dict.add(str));
-    if (props.exclude?.length)
-      await emplace(props.filter)(props.exclude)((str) => dict.delete(str));
-
-    return [...dict];
-  };
-
-  const emplace =
-    (filter: (file: string) => boolean) =>
-    (input: string[]) =>
-    async (closure: (location: string) => void): Promise<void> => {
-      for (const pattern of input) {
-        for (const file of await _Glob(path.resolve(pattern))) {
-          const stats: fs.Stats = await fs.promises.stat(file);
-          if (stats.isDirectory() === true)
-            await iterate(filter)(closure)(file);
-          else if (stats.isFile() && filter(file)) closure(file);
-        }
-      }
-    };
-
-  const iterate =
-    (filter: (location: string) => boolean) =>
-    (closure: (location: string) => void) =>
-    async (location: string): Promise<void> => {
-      const directory: string[] = await fs.promises.readdir(location);
-      for (const file of directory) {
-        const next: string = path.resolve(`${location}/${file}`);
-        const stats: fs.Stats = await fs.promises.stat(next);
-
-        if (stats.isDirectory() === true) await iterate(filter)(closure)(next);
-        else if (stats.isFile() && filter(next)) closure(next);
-      }
-    };
-
-  const _Glob = async (pattern: string): Promise<string[]> => {
-    const matches = await glob(pattern);
-    return matches.map((str) => path.resolve(str));
-  };
-}
-
-interface IProps {
-  exclude?: string[];
-  include: string[];
-  filter: (location: string) => boolean;
-}
+import fs from "fs";
+import { glob } from "glob";
+import path from "path";
+
+export namespace SourceFinder {
+  export const find = async (props: IProps): Promise<string[]> => {
+    const dict: Set<string> = new Set();
+
+    await emplace(props.filter)(props.include)((str) => dict.add(str));
+    if (props.exclude?.length)
+      await emplace(props.filter)(props.exclude)((str) => dict.delete(str));
+
+    return [...dict];
+  };
+
+  const emplace =
+    (filter: (file: string) => boolean) =>
+    (input: string[]) =>
+    async (closure: (location: string) => void): Promise<void> => {
+      for (const pattern of input) {
+        for (const file of await _Glob(path.resolve(pattern))) {
+          const stats: fs.Stats = await fs.promises.stat(file);
+          if (stats.isDirectory() === true)
+            await iterate(filter)(closure)(file);
+          else if (stats.isFile() && filter(file)) closure(file);
+        }
+      }
+    };
+
+  const iterate =
+    (filter: (location: string) => boolean) =>
+    (closure: (location: string) => void) =>
+    async (location: string): Promise<void> => {
+      const directory: string[] = await fs.promises.readdir(location);
+      for (const file of directory) {
+        const next: string = path.resolve(`${location}/${file}`);
+        const stats: fs.Stats = await fs.promises.stat(next);
+
+        if (stats.isDirectory() === true) await iterate(filter)(closure)(next);
+        else if (stats.isFile() && filter(next)) closure(next);
+      }
+    };
+
+  const _Glob = async (pattern: string): Promise<string[]> => {
+    const matches = await glob(pattern);
+    return matches.map((str) => path.resolve(str));
+  };
+}
+
+interface IProps {
+  exclude?: string[];
+  include: string[];
+  filter: (location: string) => boolean;
+}

package/src/utils/VersioningStrategy.ts

@@ -1,27 +1,27 @@
-import { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
-
-export namespace VersioningStrategy {
-  export interface IConfig {
-    prefix: string;
-    defaultVersion?: VersionValue;
-  }
-
-  export const cast = (
-    value: VersionValue | undefined,
-  ): Array<string | typeof VERSION_NEUTRAL> =>
-    value === undefined ? [] : Array.isArray(value) ? value : [value];
-
-  export const merge =
-    (config: IConfig | undefined) =>
-    (values: Array<string | typeof VERSION_NEUTRAL>): string[] => {
-      if (config === undefined) return [""];
-      const set: Set<string | typeof VERSION_NEUTRAL> = new Set(values);
-      const array: Array<string | typeof VERSION_NEUTRAL> =
-        set.size === 0 ? cast(config.defaultVersion) : Array.from(set);
-      return !!array?.length
-        ? array.map((x) =>
-            typeof x === "symbol" ? "" : `${config.prefix}${x}`,
-          )
-        : [];
-    };
-}
+import { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
+
+export namespace VersioningStrategy {
+  export interface IConfig {
+    prefix: string;
+    defaultVersion?: VersionValue;
+  }
+
+  export const cast = (
+    value: VersionValue | undefined,
+  ): Array<string | typeof VERSION_NEUTRAL> =>
+    value === undefined ? [] : Array.isArray(value) ? value : [value];
+
+  export const merge =
+    (config: IConfig | undefined) =>
+    (values: Array<string | typeof VERSION_NEUTRAL>): string[] => {
+      if (config === undefined) return [""];
+      const set: Set<string | typeof VERSION_NEUTRAL> = new Set(values);
+      const array: Array<string | typeof VERSION_NEUTRAL> =
+        set.size === 0 ? cast(config.defaultVersion) : Array.from(set);
+      return !!array?.length
+        ? array.map((x) =>
+            typeof x === "symbol" ? "" : `${config.prefix}${x}`,
+          )
+        : [];
+    };
+}

package/native/transform/cleanup_test.go

@@ -1,76 +0,0 @@
-package transform
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestCleanupTransformedTextWithRuntimeAliases(t *testing.T) {
-	input := strings.Join([]string{
-		`"use strict";`,
-		`const typia_1 = require("typia");`,
-		`const value = __typia_transform__isTypeInt32(input);`,
-		``,
-	}, "\n")
-
-	output := cleanupTransformedTextWithRuntimeAliases(
-		input,
-		[]string{"__typia_transform__isTypeInt32"},
-	)
-
-	if strings.Contains(output, `require("typia");`) {
-		t.Fatalf("unused typia import was not removed:\n%s", output)
-	}
-	expected := `const { _isTypeInt32: __typia_transform__isTypeInt32 } = require("typia/lib/internal/_isTypeInt32");`
-	if strings.Contains(output, expected) == false {
-		t.Fatalf("runtime import was not injected:\n%s", output)
-	}
-	if strings.Index(output, expected) >= strings.Index(output, "const value") {
-		t.Fatalf("runtime import was inserted after usage:\n%s", output)
-	}
-}
-
-func TestCleanupTransformedTextKeepsReferencedTypiaImport(t *testing.T) {
-	input := strings.Join([]string{
-		`"use strict";`,
-		`const typia_1 = require("typia");`,
-		`const value = typia_1.default.assert(input);`,
-		``,
-	}, "\n")
-
-	output := cleanupTransformedTextWithRuntimeAliases(input, []string{})
-	if strings.Contains(output, `const typia_1 = require("typia");`) == false {
-		t.Fatalf("referenced typia import was removed:\n%s", output)
-	}
-}
-
-func TestCleanupTransformedTextDoesNotDuplicateRuntimeImport(t *testing.T) {
-	existing := `const { _isTypeInt32: __typia_transform__isTypeInt32 } = require("typia/lib/internal/_isTypeInt32");`
-	input := strings.Join([]string{
-		`"use strict";`,
-		existing,
-		`const value = __typia_transform__isTypeInt32(input);`,
-		``,
-	}, "\n")
-
-	output := cleanupTransformedTextWithRuntimeAliases(
-		input,
-		[]string{"__typia_transform__isTypeInt32"},
-	)
-	if strings.Count(output, existing) != 1 {
-		t.Fatalf("runtime import was duplicated:\n%s", output)
-	}
-}
-
-func TestNativeRewriteSetCollectsRuntimeAliasesFromAppendArguments(t *testing.T) {
-	rewrites := newNativeRewriteSet()
-	rewrites.Add(nativeRewrite{
-		FilePath:        "/project/src/controller.ts",
-		AppendArguments: []string{`__typia_transform__httpQueryParseURLSearchParams(input)`},
-	})
-
-	aliases := rewrites.RuntimeAliasesForOutput("/project/lib/controller.js")
-	if len(aliases) != 1 || aliases[0] != "__typia_transform__httpQueryParseURLSearchParams" {
-		t.Fatalf("unexpected aliases: %#v", aliases)
-	}
-}

package/native/transform/commonjs_import_alias_test.go

@@ -1,49 +0,0 @@
-package transform
-
-import "testing"
-
-// Verifies commonJSImportAliasBase produces a valid JS identifier base
-// for every module specifier the CommonJS substitution table feeds it.
-//
-// Output forms the `<base>_N.default` substitution map that the native
-// rewrite scan looks up against tsgo's CJS emit. Any input that produces
-// a non-identifier base (leading digit, contains `-`, empty after
-// extension strip) would generate a substitution that never matches
-// tsgo's emit and silently break the rewrite for that import. The
-// reverted P-8 sat on top of this helper — locking the branches now
-// guards the rewrite contract against future emit-side changes.
-//
-//  1. Letters / digits / `_` / `$` survive verbatim.
-//  2. Non-identifier characters (dashes, dots, slashes) become `_`.
-//  3. Empty or pathological bases (`.`, `/`) fall back to `mod`.
-//  4. Leading digits are prefixed with `_` so the base is identifier-safe.
-//  5. Unicode letters survive (Go's `unicode.IsLetter`).
-//  6. File extensions are stripped before sanitization.
-func TestCommonJSImportAliasBaseProducesIdentifierSafeName(t *testing.T) {
-	cases := []struct {
-		name   string
-		module string
-		want   string
-	}{
-		{"plain package", "typia", "typia"},
-		{"scoped package", "@nestia/core", "core"},
-		{"dotted package", "lodash.merge", "lodash"},
-		{"path with slashes", "@nestia/core/lib/transform", "transform"},
-		{"dashes become underscores", "kebab-case-lib", "kebab_case_lib"},
-		{"trailing extension stripped", "module.mjs", "module"},
-		{"empty becomes mod", "", "mod"},
-		{"dot becomes mod", ".", "mod"},
-		{"leading digit prefixed with underscore", "1abc", "_1abc"},
-		{"underscore start preserved", "_internal", "_internal"},
-		{"dollar start preserved", "$jq", "$jq"},
-		{"unicode letter preserved", "한글", "한글"},
-		{"mixed special chars sanitized", "foo.bar-baz", "foo"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := commonJSImportAliasBase(tc.module); got != tc.want {
-				t.Fatalf("commonJSImportAliasBase(%q) = %q, want %q", tc.module, got, tc.want)
-			}
-		})
-	}
-}