@nestia/core 11.2.1 → 12.0.0-dev.20260521.1

package/native/transform/typia_fast.go

@@ -0,0 +1,326 @@
+package transform
+
+import (
+	"path/filepath"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
+)
+
+type nestiaTypiaImportRoot struct {
+	module string
+}
+
+func collectNestiaTypiaCallSites(files []*shimast.SourceFile, checker *shimchecker.Checker) []typiaadapter.CallSite {
+	sites := []typiaadapter.CallSite{}
+	for _, file := range files {
+		if file == nil || file.IsDeclarationFile {
+			continue
+		}
+		roots, fallback := nestiaTypiaImportRoots(file)
+		if len(roots) == 0 {
+			if fallback {
+				sites = append(sites, typiaadapter.CollectCallSites([]*shimast.SourceFile{file}, checker)...)
+			}
+			continue
+		}
+		file.ForEachChild(func(node *shimast.Node) bool {
+			visitNestiaTypiaCallSite(file, checker, roots, node, &sites)
+			return false
+		})
+	}
+	return sites
+}
+
+func visitNestiaTypiaCallSite(
+	file *shimast.SourceFile,
+	checker *shimchecker.Checker,
+	roots map[string]nestiaTypiaImportRoot,
+	node *shimast.Node,
+	sites *[]typiaadapter.CallSite,
+) {
+	if node == nil {
+		return
+	}
+	if node.Kind == shimast.KindCallExpression {
+		call := node.AsCallExpression()
+		if call != nil && nestiaTypiaCallLooksPossible(call, roots) {
+			if site, ok := tryNestiaTypiaCallSite(file, checker, node); ok {
+				*sites = append(*sites, site)
+			}
+		}
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		visitNestiaTypiaCallSite(file, checker, roots, child, sites)
+		return false
+	})
+}
+
+func nestiaTypiaImportRoots(file *shimast.SourceFile) (map[string]nestiaTypiaImportRoot, bool) {
+	roots := map[string]nestiaTypiaImportRoot{}
+	fallback := false
+	if file == nil || file.Statements == nil {
+		return roots, fallback
+	}
+	for _, stmt := range file.Statements.Nodes {
+		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+			continue
+		}
+		decl := stmt.AsImportDeclaration()
+		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+			continue
+		}
+		moduleText := decl.ModuleSpecifier.Text()
+		module, ok := nestiaTypiaImportModule(moduleText)
+		if ok == false {
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
+			continue
+		}
+		if name := clause.Name(); name != nil {
+			roots[name.Text()] = nestiaTypiaImportRoot{module: module}
+		}
+		if clause.NamedBindings == nil {
+			continue
+		}
+		if clause.NamedBindings.Kind == shimast.KindNamespaceImport {
+			if name := clause.NamedBindings.Name(); name != nil {
+				roots[name.Text()] = nestiaTypiaImportRoot{module: module}
+			}
+			continue
+		}
+		if clause.NamedBindings.Kind != shimast.KindNamedImports {
+			continue
+		}
+		named := clause.NamedBindings.AsNamedImports()
+		if named == nil || named.Elements == nil {
+			continue
+		}
+		for _, elem := range named.Elements.Nodes {
+			if elem == nil {
+				continue
+			}
+			spec := elem.AsImportSpecifier()
+			if spec == nil || spec.IsTypeOnly {
+				continue
+			}
+			name := spec.Name()
+			if name == nil {
+				continue
+			}
+			imported := name.Text()
+			if spec.PropertyName != nil {
+				imported = spec.PropertyName.Text()
+			}
+			if module == "" {
+				if nestiaTypiaKnownModule(imported) == false {
+					continue
+				}
+				roots[name.Text()] = nestiaTypiaImportRoot{module: imported}
+			} else {
+				roots[name.Text()] = nestiaTypiaImportRoot{module: module}
+			}
+		}
+	}
+	return roots, fallback
+}
+
+func nestiaTypiaImportModule(specifier string) (string, bool) {
+	switch specifier {
+	case "typia":
+		return "", true
+	}
+	for _, prefix := range []string{"typia/lib/", "typia/src/"} {
+		if strings.HasPrefix(specifier, prefix) {
+			name := strings.TrimPrefix(specifier, prefix)
+			if strings.Contains(name, "/") || nestiaTypiaKnownModule(name) == false {
+				return "", false
+			}
+			return name, true
+		}
+	}
+	return "", false
+}
+
+func nestiaTypiaKnownModule(name string) bool {
+	switch name {
+	case "functional", "http", "json", "llm", "misc", "module", "notations", "protobuf", "reflect":
+		return true
+	default:
+		return false
+	}
+}
+
+func nestiaTypiaCallLooksPossible(call *shimast.CallExpression, roots map[string]nestiaTypiaImportRoot) bool {
+	root, parts, ok := nestiaTypiaCallSegments(call)
+	if ok == false {
+		return false
+	}
+	info, ok := roots[root]
+	if ok == false || len(parts) == 0 {
+		return false
+	}
+	if info.module != "" {
+		return true
+	}
+	if len(parts) == 1 {
+		return true
+	}
+	return nestiaTypiaKnownModule(parts[0])
+}
+
+func nestiaTypiaCallSegments(call *shimast.CallExpression) (string, []string, bool) {
+	if call == nil {
+		return "", nil, false
+	}
+	expression := call.Expression
+	parts := []string{}
+	for expression != nil && expression.Kind == shimast.KindPropertyAccessExpression {
+		property := expression.AsPropertyAccessExpression()
+		if property == nil {
+			return "", nil, false
+		}
+		name := property.Name()
+		if name == nil || name.Kind != shimast.KindIdentifier {
+			return "", nil, false
+		}
+		id := name.AsIdentifier()
+		if id == nil || id.Text == "" {
+			return "", nil, false
+		}
+		parts = append([]string{id.Text}, parts...)
+		expression = property.Expression
+	}
+	if expression == nil || expression.Kind != shimast.KindIdentifier {
+		return "", nil, false
+	}
+	root := expression.AsIdentifier()
+	if root == nil || root.Text == "" {
+		return "", nil, false
+	}
+	return root.Text, parts, true
+}
+
+func tryNestiaTypiaCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node) (typiaadapter.CallSite, bool) {
+	if checker == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	call := node.AsCallExpression()
+	if call == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	signature := checker.GetResolvedSignature(node)
+	if signature == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	declaration := signature.Declaration()
+	if declaration == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	sourceFile := shimast.GetSourceFileOfNode(declaration)
+	if sourceFile == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	module, ok := nestiaTypiaMatchModule(sourceFile.FileName())
+	if !ok {
+		return typiaadapter.CallSite{}, false
+	}
+	method := nestiaTypiaCallSiteMethodName(checker, declaration, call)
+	if method == "" {
+		return typiaadapter.CallSite{}, false
+	}
+	root, namespaces, ok := nestiaTypiaExtractRootAndNamespaces(call, method)
+	if !ok {
+		return typiaadapter.CallSite{}, false
+	}
+	return typiaadapter.CallSite{
+		File:       file,
+		FilePath:   file.FileName(),
+		Module:     module,
+		Method:     method,
+		Call:       call,
+		RootName:   root,
+		Namespaces: namespaces,
+	}, true
+}
+
+func nestiaTypiaMatchModule(location string) (string, bool) {
+	location = filepath.ToSlash(location)
+	for _, suffix := range []string{".d.ts", ".ts"} {
+		for _, middle := range []string{"typia/lib/", "typia/src/", "packages/typia/src/"} {
+			index := strings.LastIndex(location, middle)
+			if index < 0 {
+				continue
+			}
+			name := location[index+len(middle):]
+			if !strings.HasSuffix(name, suffix) {
+				continue
+			}
+			name = strings.TrimSuffix(name, suffix)
+			if strings.Contains(name, "/") {
+				continue
+			}
+			return name, true
+		}
+	}
+	return "", false
+}
+
+func nestiaTypiaCallSiteMethodName(checker *shimchecker.Checker, declaration *shimast.Node, call *shimast.CallExpression) string {
+	if name := declaration.Name(); name != nil {
+		if symbol := checker.GetSymbolAtLocation(name); symbol != nil && symbol.Name != "" {
+			return symbol.Name
+		}
+		if name.Kind == shimast.KindIdentifier {
+			if id := name.AsIdentifier(); id != nil {
+				return id.Text
+			}
+		}
+	}
+	if call.Expression != nil && call.Expression.Kind == shimast.KindPropertyAccessExpression {
+		if property := call.Expression.AsPropertyAccessExpression(); property != nil {
+			if name := property.Name(); name != nil && name.Kind == shimast.KindIdentifier {
+				if id := name.AsIdentifier(); id != nil {
+					return id.Text
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func nestiaTypiaExtractRootAndNamespaces(call *shimast.CallExpression, method string) (string, []string, bool) {
+	expression := call.Expression
+	segments := []string{}
+	for expression != nil && expression.Kind == shimast.KindPropertyAccessExpression {
+		property := expression.AsPropertyAccessExpression()
+		if property == nil {
+			break
+		}
+		name := property.Name()
+		if name == nil || name.Kind != shimast.KindIdentifier {
+			return "", nil, false
+		}
+		id := name.AsIdentifier()
+		if id == nil || id.Text == "" {
+			return "", nil, false
+		}
+		segments = append([]string{id.Text}, segments...)
+		expression = property.Expression
+	}
+	if expression == nil || expression.Kind != shimast.KindIdentifier {
+		return "", nil, false
+	}
+	root := expression.AsIdentifier()
+	if root == nil || root.Text == "" || len(segments) == 0 {
+		return "", nil, false
+	}
+	if segments[len(segments)-1] != method {
+		return "", nil, false
+	}
+	return root.Text, segments[:len(segments)-1], true
+}

package/native/transform/typia_replacement.go

@@ -0,0 +1,24 @@
+package transform
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
+)
+
+func parenthesizeTypiaReplacement(
+	site typiaadapter.CallSite,
+	expr string,
+) string {
+	text := strings.TrimSpace(expr)
+	if strings.HasPrefix(text, "{") == false {
+		return expr
+	}
+	node := site.Call.AsNode()
+	if node == nil || node.Parent == nil ||
+		node.Parent.Kind != shimast.KindExpressionStatement {
+		return expr
+	}
+	return "(" + expr + ")"
+}

package/native/transform.cjs

@@ -0,0 +1,43 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+// `@nestia/core` ttsc plugin descriptor.
+//
+// `source` is the Go command package of the executable transform host
+// (`cmd/ttsc-nestia`, package `main`).
+//
+// `@nestia/sdk` is NOT a standalone ttsc plugin: its Go transform is declared
+// here as a `contributor`, discovered by resolving `@nestia/sdk` from the
+// project. ttsc statically links a contributor's Go source into this host
+// binary. Consequences:
+//
+//   - A project that depends on `@nestia/core` but not `@nestia/sdk` never
+//     links, compiles, or ships any SDK transform code.
+//   - When the `@nestia/core` plugin itself is disabled, this descriptor is
+//     never evaluated, so the SDK contributor is never linked either.
+function createTtscPlugin(context) {
+  const plugin = {
+    name: "@nestia/core",
+    source: path.resolve(__dirname, "cmd", "ttsc-nestia"),
+    composes: ["typia/lib/transform"],
+  };
+  const sdk = resolveSdkContributorSource(context);
+  if (sdk !== null) plugin.contributors = [{ name: "sdk", source: sdk }];
+  return plugin;
+}
+
+function resolveSdkContributorSource(context) {
+  const paths = [__dirname];
+  if (context && typeof context.projectRoot === "string")
+    paths.push(context.projectRoot);
+  try {
+    const manifest = require.resolve("@nestia/sdk/package.json", { paths });
+    const source = path.resolve(path.dirname(manifest), "native", "sdk");
+    return fs.existsSync(source) ? source : null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = createTtscPlugin;
+module.exports.createTtscPlugin = createTtscPlugin;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@nestia/core",
-  "version": "11.2.1",
+  "version": "12.0.0-dev.20260521.1",
   "description": "Super-fast validation decorators of NestJS",
+  "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "exports": {
     ".": {
@@ -12,6 +13,7 @@
       "types": "./lib/transform.d.ts",
       "default": "./lib/transform.js"
     },
+    "./native/transform.cjs": "./native/transform.cjs",
     "./package.json": "./package.json"
   },
   "tsp": {
@@ -19,6 +21,11 @@
       "parseAllJsDoc": true
     }
   },
+  "ttsc": {
+    "plugin": {
+      "transform": "@nestia/core/native/transform.cjs"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/samchon/nestia"
@@ -39,10 +46,8 @@
   },
   "homepage": "https://nestia.io",
   "dependencies": {
-    "@typia/core": "12.1.0",
-    "@typia/interface": "12.1.0",
-    "@typia/utils": "12.1.0",
-    "detect-ts-node": "^1.0.5",
+    "@typia/interface": "13.0.0-dev.20260521.1",
+    "@typia/utils": "13.0.0-dev.20260521.1",
     "get-function-location": "^2.0.0",
     "glob": "^11.0.3",
     "path-parser": "^6.1.0",
@@ -50,50 +55,51 @@
     "reflect-metadata": ">=0.1.12",
     "rxjs": ">=6.0.3",
     "tgrid": "^1.1.0",
-    "typia": "12.1.0",
+    "typia": "13.0.0-dev.20260521.1",
     "ws": "^7.5.3",
-    "@nestia/fetcher": "^11.2.1"
+    "@nestia/fetcher": "^12.0.0-dev.20260521.1"
   },
   "peerDependencies": {
     "@nestjs/common": ">=7.0.1",
     "@nestjs/core": ">=7.0.1",
     "reflect-metadata": ">=0.1.12",
     "rxjs": ">=6.0.3",
-    "typia": "12.1.0",
-    "@nestia/fetcher": "^11.2.1"
+    "typia": "13.0.0-dev.20260521.1",
+    "@nestia/fetcher": "^12.0.0-dev.20260521.1"
   },
   "devDependencies": {
     "@nestjs/common": "^11.1.6",
     "@nestjs/core": "^11.1.6",
     "@nestjs/platform-express": "^11.1.6",
+    "@typescript/native-preview": "7.0.0-dev.20260518.1",
     "@types/express": "^4.17.15",
-    "@types/inquirer": "^9.0.3",
     "@types/multer": "^1.4.12",
     "@types/ws": "^8.5.10",
-    "commander": "^10.0.0",
-    "comment-json": "^4.2.3",
-    "eslint-plugin-deprecation": "^1.4.1",
     "fastify": "^4.28.1",
-    "git-last-commit": "^1.0.1",
-    "inquirer": "^8.2.5",
     "rimraf": "^6.1.3",
-    "ts-node": "^10.9.2",
-    "tstl": "^3.0.0",
-    "typescript": "~6.0.3"
+    "ttsc": "^0.12.3",
+    "tstl": "^3.0.0"
   },
   "files": [
     "README.md",
+    "MIGRATION.md",
     "LICENSE",
     "package.json",
     "lib",
+    "native/cmd",
+    "native/go.mod",
+    "native/go.sum",
+    "native/plugin",
+    "native/transform",
+    "native/transform.cjs",
     "src"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib && tsc",
-    "dev": "rimraf lib && tsc --watch"
-  },
-  "types": "lib/index.d.ts"
+    "build": "rimraf lib && ttsc",
+    "dev": "ttsc --watch",
+    "test:go": "cd test && go test ./..."
+  }
 }

package/src/decorators/NoTransformConfigurationError.ts

@@ -4,8 +4,11 @@ export function NoTransformConfigurationError(method: string) {
     throw new Error(
       [
         `Error on nestia.core.${method}(): no transform has been configured.`,
-        `Run "npx nestia setup" command, or check if you're using non-standard TypeScript compiler like Babel or SWC.`,
-        `Otherwise you're running "npx nestia sdk/swagger" or similar, run "npx tsc" command to find the reason why.`,
+        `Build the project with "ttsc" (not stock "tsc"); the Go-backed @nestia/core transform attaches automatically through ttsc plugin auto-discovery.`,
+        `If "ttsc" is missing, run "npx nestia setup" to install the toolchain and runtime packages.`,
+        `If you're using a non-standard TypeScript compiler like Babel or SWC, the @nestia/core transformer is not available.`,
+        `If you're running "npx nestia sdk/swagger" or similar, run "npx ttsc --noEmit" to surface the underlying compilation error.`,
+        `See https://nestia.io/docs/setup for the full setup (tsgo and legacy paths); migration notes are at node_modules/@nestia/core/MIGRATION.md.`,
       ].join(" "),
     );
   return undefined as never;

package/src/decorators/internal/load_controller.ts

@@ -1,4 +1,5 @@
-import is_ts_node from "detect-ts-node";
+import fs from "fs";
+import path from "path";
 
 import { Creator } from "../../typings/Creator";
 import { SourceFinder } from "../../utils/SourceFinder";
@@ -7,24 +8,36 @@ export const load_controllers = async (
   path: string | string[] | { include: string[]; exclude?: string[] },
   isTsNode?: boolean,
 ): Promise<Creator<object>[]> => {
+  const include: string[] = Array.isArray(path)
+    ? path
+    : typeof path === "object"
+      ? path.include
+      : [path];
+  const exclude: string[] =
+    typeof path === "object" && !Array.isArray(path) ? (path.exclude ?? []) : [];
+  const filter =
+    isTsNode === true
+      ? (file: string) =>
+          file.substring(file.length - 3) === ".ts" &&
+          file.substring(file.length - 5) !== ".d.ts"
+      : (file: string) => file.substring(file.length - 3) === ".js";
   const sources: string[] = await SourceFinder.find({
-    include: Array.isArray(path)
-      ? path
-      : typeof path === "object"
-        ? path.include
-        : [path],
-    exclude:
-      typeof path === "object" && !Array.isArray(path)
-        ? (path.exclude ?? [])
-        : [],
-    filter:
-      isTsNode === true || EXTENSION === "ts"
-        ? (file) =>
-            file.substring(file.length - 3) === ".ts" &&
-            file.substring(file.length - 5) !== ".d.ts"
-        : (flle) => flle.substring(flle.length - 3) === ".js",
+    include,
+    exclude,
+    filter,
   });
-  return mount(sources);
+  const controllers: Creator<object>[] = await mount(sources);
+  if (controllers.length !== 0 || isTsNode === true) return controllers;
+
+  const runtimeRoot: string | null = findTtsxRuntimeRoot();
+  if (runtimeRoot === null) return controllers;
+
+  const fallback: string[] = await SourceFinder.find({
+    include: include.map((p) => resolveRuntimePattern(runtimeRoot, p)),
+    exclude: exclude.map((p) => resolveRuntimePattern(runtimeRoot, p)),
+    filter,
+  });
+  return fallback.length === 0 ? controllers : mount(fallback);
 };
 
 /** @internal */
@@ -41,5 +54,23 @@ async function mount(sources: string[]): Promise<any[]> {
   return controllers;
 }
 
-/** @internal */
-const EXTENSION = is_ts_node ? "ts" : "js";
+function findTtsxRuntimeRoot(): string | null {
+  const entry: string | undefined = process.argv[1];
+  if (entry === undefined) return null;
+
+  let current: string = path.resolve(entry);
+  if (fs.existsSync(current) && fs.statSync(current).isFile())
+    current = path.dirname(current);
+  while (true) {
+    if (fs.existsSync(path.join(current, ".ttsx.tsconfig.json")))
+      return current;
+    const parent: string = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function resolveRuntimePattern(runtimeRoot: string, pattern: string): string {
+  if (path.isAbsolute(pattern)) return pattern;
+  return path.resolve(runtimeRoot, pattern);
+}

package/src/decorators/internal/validate_request_query.ts

@@ -35,6 +35,7 @@ const assert =
           message: MESSAGE,
         });
       }
+      if (is_missing_query_property(exp)) return new BadRequestException(MESSAGE);
       throw exp;
     }
   };
@@ -43,7 +44,14 @@ const assert =
 const is =
   <T>(closure: (input: URLSearchParams) => T | null) =>
   (input: URLSearchParams): T | BadRequestException => {
-    const result: T | null = closure(input);
+    const result: T | null = (() => {
+      try {
+        return closure(input);
+      } catch (exp) {
+        if (is_missing_query_property(exp)) return null;
+        throw exp;
+      }
+    })();
     return result !== null ? result : new BadRequestException(MESSAGE);
   };
 
@@ -51,7 +59,15 @@ const is =
 const validate =
   <T>(closure: (input: URLSearchParams) => IValidation<T>) =>
   (input: URLSearchParams): T | BadRequestException => {
-    const result: IValidation<T> = closure(input);
+    const result: IValidation<T> | null = (() => {
+      try {
+        return closure(input);
+      } catch (exp) {
+        if (is_missing_query_property(exp)) return null;
+        throw exp;
+      }
+    })();
+    if (result === null) return new BadRequestException(MESSAGE);
     return result.success
       ? result.data
       : new BadRequestException({
@@ -62,3 +78,6 @@ const validate =
 
 /** @internal */
 const MESSAGE = "Request query data is not following the promised type.";
+
+const is_missing_query_property = (exp: unknown): exp is Error =>
+  exp instanceof Error && /^missing [^.\[\]\s]+$/.test(exp.message);