@nestia/core 11.2.1 → 12.0.0-dev.20260521.1

package/native/transform/rewrite_test.go

@@ -0,0 +1,118 @@
+package transform
+
+import "testing"
+
+// Verifies OutputMatchesSourceStem accepts virtual-fs same-stem mirrors and
+// rejects single-segment suffix collisions across the source tree.
+//
+// Regression: a top-level `src/index.ts` produced a one-segment relative
+// ("index") that the HasSuffix fallback matched against every output ending
+// in `/index.js`. The native rewrite scan then trawled unrelated files for
+// typia call sites that only existed in the root entry, raising
+// "could not locate typia.reflect.schemas(...) call".
+//
+//  1. Mirror a src/index virtual fs — must match.
+//  2. Compare top-level src/index against nested src/api/health/index — must reject.
+//  3. Cover the package src->lib mapping and an unrelated stem pair.
+func TestOutputMatchesSourceStem(t *testing.T) {
+	cases := []struct {
+		name   string
+		output string
+		source string
+		want   bool
+	}{
+		{
+			name:   "virtual fs mirrors src tree",
+			output: "/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/index",
+			source: "/repo/tests/foo/src/index",
+			want:   true,
+		},
+		{
+			name:   "top-level src/index does not match nested src/api/health/index",
+			output: "/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/api/functional/health/index",
+			source: "/repo/tests/foo/src/index",
+			want:   false,
+		},
+		{
+			name:   "src/api source matches nested api output",
+			output: "/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/api/functional/health/index",
+			source: "/repo/tests/foo/src/api/functional/health/index",
+			want:   true,
+		},
+		{
+			name:   "package src maps to lib output",
+			output: "/repo/packages/core/lib/decorators/TypedBody",
+			source: "/repo/packages/core/src/decorators/TypedBody",
+			want:   true,
+		},
+		{
+			name:   "unrelated stems",
+			output: "/repo/packages/core/lib/decorators/TypedBody",
+			source: "/repo/packages/sdk/src/generates/Foo",
+			want:   false,
+		},
+		{
+			name:   "top-level src/index does not match nested src/api/index",
+			output: "/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/api/index",
+			source: "/repo/tests/foo/src/index",
+			want:   false,
+		},
+	}
+	for _, tc := range cases {
+		got := OutputMatchesSourceStem(tc.output, tc.source)
+		if got != tc.want {
+			t.Errorf("%s: OutputMatchesSourceStem(%q, %q) = %v, want %v",
+				tc.name, tc.output, tc.source, got, tc.want)
+		}
+	}
+}
+
+func TestCountNativeArgumentsBasic(t *testing.T) {
+	cases := []struct {
+		name string
+		in   string
+		want int
+	}{
+		{"empty", "", 0},
+		{"single", "x", 1},
+		{"two simple", "a, b", 2},
+		{"three with object", "a, { b: 1, c: 2 }, d", 3},
+		{"comma in string", `"a, b", c`, 2},
+		{"comma in single quote", `'a, b', c, d`, 3},
+		{"escaped quote", `"a\"b", c`, 2},
+		{"comma in template", "`a,b`, c", 2},
+		{"nested call", "foo(a, b), c", 2},
+		{"nested array", "[1, 2, 3], y", 2},
+	}
+	for _, tc := range cases {
+		got := countNativeArguments(tc.in)
+		if got != tc.want {
+			t.Errorf("%s: countNativeArguments(%q) = %d, want %d", tc.name, tc.in, got, tc.want)
+		}
+	}
+}
+
+// Regression: template-literal `${...}` substitutions contain real expressions
+// — any '(' / ')' / ',' inside a substitution must be treated as expression
+// tokens, not template-string content. Prior implementation skipped the entire
+// backtick range as if it were a flat string and miscounted arguments when a
+// substitution contained quote-shaped characters or nested templates.
+func TestCountNativeArgumentsTemplateSubstitution(t *testing.T) {
+	cases := []struct {
+		name string
+		in   string
+		want int
+	}{
+		{"quote-inside-substitution", "`x${\")\"}y`, foo", 2},
+		{"comma-inside-substitution-grouped", "`x${(1, 2)}y`, foo", 2},
+		{"nested-template", "`a${`b${1}c`}d`, foo", 2},
+		{"substitution-with-object", "`x${{ a: 1, b: 2 }}y`, foo", 2},
+		{"call-inside-substitution", "`x${ f(1, 2) }y`, foo", 2},
+	}
+	for _, tc := range cases {
+		got := countNativeArguments(tc.in)
+		if got != tc.want {
+			t.Errorf("%s: countNativeArguments(%q) = %d, want %d", tc.name, tc.in, got, tc.want)
+		}
+	}
+}

package/native/transform/rewrite_unique_base_test.go

@@ -0,0 +1,48 @@
+package transform
+
+import "testing"
+
+func TestNativeRewriteSetFindSourceByUniqueBase(t *testing.T) {
+	set := newNativeRewriteSet()
+	set.Add(nativeRewrite{
+		FilePath: "/repo/tests/test-transform-options/src/validate.ts",
+		Method:   "TypedBody",
+	})
+
+	got, ok := set.findSourceForOutput(
+		"/repo/tests/test-transform-options/lib/validate-assert/validate.js",
+	)
+	if !ok {
+		t.Fatal("expected unique basename fallback to match source")
+	}
+	if got != "/repo/tests/test-transform-options/src/validate.ts" {
+		t.Fatalf("unexpected source match: %q", got)
+	}
+}
+
+// Verifies the unique-basename fallback does not match a sibling output that
+// lives inside the same `src/` tree as the registered source.
+//
+// Regression: the fallback used to match any output sharing a basename with
+// a registered source, so `src/index.ts` silently absorbed rewrites destined
+// for every `src/.../index.ts` neighbor produced by ttsc's virtual fs. The
+// symptom was `could not locate typia.*(...)` on unrelated generated files.
+//
+//  1. Register one rewrite for `/repo/tests/foo/src/index.ts`.
+//  2. Ask findSourceForOutput for a sibling output inside the same src tree.
+//  3. Expect no match.
+func TestNativeRewriteSetFindSourceByUniqueBaseSkipsSourceTreeSiblings(t *testing.T) {
+	set := newNativeRewriteSet()
+	set.Add(nativeRewrite{
+		FilePath: "/repo/tests/foo/src/index.ts",
+		Method:   "schemas",
+	})
+
+	// Output sits inside the same src/ tree, not in lib/dist/bin/build — it
+	// must not absorb the rewrite registered for src/index.ts.
+	if got, ok := set.findSourceForOutput(
+		"/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/api/functional/health/index.js",
+	); ok {
+		t.Fatalf("expected no match for source-tree sibling, got %q", got)
+	}
+}

package/native/transform/run.go

@@ -0,0 +1,72 @@
+package transform
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime/debug"
+)
+
+var (
+	stdout io.Writer = os.Stdout
+	stderr io.Writer = os.Stderr
+)
+
+// Run wraps run() in a panic recovery envelope so that any unexpected
+// panic surfaces as a one-line transform-diagnostic on stderr instead of
+// a multi-line raw Go stack trace. The diagnostic uses the same `<file> -
+// error TS(code): message` shape as every other nestia / typia diagnostic;
+// ttsc reads it via `error.stderr` (`RuntimeCompiler.compile` at
+// `ConfigAnalyzer.ts:170-174`) rather than its structured-diagnostic regex,
+// which is a pre-existing protocol shared by all `nestia.*` codes. The
+// full stack is preserved behind NESTIA_NATIVE_DEBUG_STACK for triage.
+//
+// This is the `@nestia/core` plugin entry point — it performs the typia
+// and `@nestia/core` decorator transforms only. The `@nestia/sdk` metadata
+// transform lives in its own plugin (`packages/sdk/native`).
+func Run(args []string) (code int) {
+	defer func() {
+		if exp := recover(); exp != nil {
+			diag := Diagnostic{
+				Code:    "nestia.internal.panic",
+				Message: fmt.Sprintf("ttsc-nestia panicked: %v", exp),
+			}
+			WriteTypiaTransformDiagnostics(stderr, []Diagnostic{diag}, "")
+			if os.Getenv("NESTIA_NATIVE_DEBUG_STACK") != "" {
+				fmt.Fprintln(stderr, string(debug.Stack()))
+			}
+			code = 3
+		}
+	}()
+	return run(args)
+}
+
+func run(args []string) int {
+	if len(args) == 0 {
+		return runHelp(nil)
+	}
+	command := args[0]
+	rest := args[1:]
+	switch command {
+	case "build":
+		return runBuild(rest)
+	case "check":
+		return runCheck(rest)
+	case "transform":
+		return runTransform(rest)
+	case "version":
+		fmt.Fprintln(stdout, "ttsc-nestia 0.1.0")
+		return 0
+	case "help", "-h", "--help":
+		return runHelp(rest)
+	default:
+		fmt.Fprintf(stderr, "ttsc-nestia: unknown command %q\n", command)
+		return 2
+	}
+}
+
+func runHelp(args []string) int {
+	_ = args
+	fmt.Fprintln(stdout, "usage: ttsc-nestia <build|check|transform|version>")
+	return 0
+}

package/native/transform/transform.go

@@ -0,0 +1,376 @@
+package transform
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/samchon/nestia/packages/core/native/plugin"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
+)
+
+type transformProjectOutput struct {
+	Diagnostics []transformCompilerDiagnostic `json:"diagnostics,omitempty"`
+	TypeScript  map[string]string             `json:"typescript"`
+}
+
+type transformCompilerDiagnostic struct {
+	File        *string `json:"file"`
+	Category    string  `json:"category"`
+	Code        string  `json:"code"`
+	Line        int     `json:"line,omitempty"`
+	Character   int     `json:"character,omitempty"`
+	MessageText string  `json:"messageText"`
+}
+
+func runTransform(args []string) int {
+	fs := flag.NewFlagSet("transform", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	file := fs.String("file", "", "absolute or cwd-relative path of the .ts file to transform")
+	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "tsconfig.json owning --file")
+	cwdOverride := fs.String("cwd", "", "override the working directory")
+	out := fs.String("out", "", "write output to PATH")
+	output := fs.String("output", "ts", "transform output kind: ts")
+	pluginsJSON := fs.String("plugins-json", "", "ordered ttsc plugin payload")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	if *output != "ts" {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: unknown --output value %q\n", *output)
+		return 2
+	}
+	plan, err := plugin.ParsePlan(*pluginsJSON)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: %v\n", err)
+		return 2
+	}
+
+	cwd, ok := resolveCWD("ttsc-nestia transform", *cwdOverride)
+	if !ok {
+		return 2
+	}
+	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+		ForceNoEmit: true,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: %v\n", err)
+		return 2
+	}
+	if len(diags) > 0 {
+		driver.WritePrettyDiagnostics(stderr, diags, cwd)
+		return 2
+	}
+	defer prog.Close()
+
+	if *file == "" {
+		if *out != "" {
+			fmt.Fprintln(stderr, "ttsc-nestia transform: --out requires --file")
+			return 2
+		}
+		return runTransformProject(prog, cwd, *tsconfigPath, plan)
+	}
+
+	absFile := *file
+	if !filepath.IsAbs(absFile) {
+		absFile = filepath.Join(cwd, absFile)
+	}
+	absFile = filepath.ToSlash(absFile)
+	target := prog.SourceFile(absFile)
+	if target == nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: source file is not in program: %s\n", absFile)
+		return 2
+	}
+	rewrites, diagnostics := collectTypiaSourceRewrites(
+		prog,
+		cwd,
+		absFile,
+		readTypiaPluginOptions(cwd, *tsconfigPath),
+	)
+	if len(diagnostics) > 0 {
+		WriteTypiaTransformDiagnostics(stderr, diagnostics, cwd)
+		return 3
+	}
+	coreRewriteMap, coreDiagnostics := collectNestiaCoreSourceRewriteMap(prog, plan, absFile)
+	if len(coreDiagnostics) > 0 {
+		WriteTypiaTransformDiagnostics(stderr, coreDiagnostics, cwd)
+		return 3
+	}
+	rewrites = append(rewrites, coreRewriteMap[filepath.ToSlash(absFile)]...)
+	source, ok := SourceFileText(target)
+	if !ok {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: source text is unavailable for %s\n", absFile)
+		return 3
+	}
+	source, err = ApplySourceRewrites(source, rewrites)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: source rewrite: %v\n", err)
+		return 3
+	}
+	source = cleanupTypeScriptTransformText(source)
+	if *out == "" {
+		if _, err := bytes.NewBufferString(source).WriteTo(stdout); err != nil {
+			fmt.Fprintf(stderr, "ttsc-nestia transform: write stdout: %v\n", err)
+			return 3
+		}
+		return 0
+	}
+	if dir := filepath.Dir(*out); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			fmt.Fprintf(stderr, "ttsc-nestia transform: mkdir: %v\n", err)
+			return 3
+		}
+	}
+	if err := os.WriteFile(*out, []byte(source), 0o644); err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: write %s: %v\n", *out, err)
+		return 3
+	}
+	return 0
+}
+
+func runTransformProject(prog *driver.Program, cwd string, tsconfigPath string, plan plugin.Plan) int {
+	rewrites, diags := collectTypiaSourceRewriteMap(
+		prog,
+		readTypiaPluginOptions(cwd, tsconfigPath),
+	)
+	coreRewriteMap, coreDiags := collectNestiaCoreSourceRewriteMap(prog, plan, "")
+	for file, entries := range coreRewriteMap {
+		rewrites[file] = append(rewrites[file], entries...)
+	}
+	diags = append(diags, coreDiags...)
+	output := transformProjectOutput{
+		Diagnostics: make([]transformCompilerDiagnostic, 0, len(diags)),
+		TypeScript:  map[string]string{},
+	}
+	for _, diag := range diags {
+		output.Diagnostics = append(output.Diagnostics, transformDiagnosticToCompilerDiagnostic(diag))
+	}
+	for _, file := range prog.SourceFiles() {
+		filename := filepath.ToSlash(file.FileName())
+		source, ok := SourceFileText(file)
+		if !ok {
+			output.Diagnostics = append(
+				output.Diagnostics,
+				newTransformCompilerDiagnostic(filename, "nestia.transform", "source text is unavailable"),
+			)
+			continue
+		}
+		transformed, err := ApplySourceRewrites(source, rewrites[filename])
+		if err != nil {
+			output.Diagnostics = append(
+				output.Diagnostics,
+				newTransformCompilerDiagnostic(filename, "typia.transform", err.Error()),
+			)
+			continue
+		}
+		output.TypeScript[sourceFileKey(cwd, filename)] = cleanupTypeScriptTransformText(transformed)
+	}
+	if err := json.NewEncoder(stdout).Encode(output); err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: encode output: %v\n", err)
+		return 3
+	}
+	if len(output.Diagnostics) > 0 {
+		return 3
+	}
+	return 0
+}
+
+type SourceRewrite struct {
+	start       int
+	end         int
+	replacement string
+}
+
+func collectTypiaSourceRewrites(
+	prog *driver.Program,
+	cwd string,
+	onlyFile string,
+	pluginOptions typiaadapter.PluginOptions,
+) ([]SourceRewrite, []Diagnostic) {
+	sites := collectNestiaTypiaCallSites(prog.SourceFiles(), prog.Checker)
+	rewrites := []SourceRewrite{}
+	diagnostics := []Diagnostic{}
+	for _, site := range sites {
+		if filepath.ToSlash(site.FilePath) != filepath.ToSlash(onlyFile) {
+			continue
+		}
+		if reason := typiaadapter.UnsupportedReason(site); reason != "" {
+			diagnostics = append(diagnostics, NewDiagnostic(site, reason))
+			continue
+		}
+		expr, handled, err := typiaadapter.EmitCallWithOptionsPreservingTypes(prog, site, pluginOptions)
+		if !handled {
+			diagnostics = append(diagnostics, NewDiagnostic(site, "method not covered"))
+			continue
+		}
+		if err != nil {
+			diagnostics = append(diagnostics, NewDiagnostic(site, err.Error()))
+			continue
+		}
+		expr = parenthesizeTypiaReplacement(site, expr)
+		node := site.Call.AsNode()
+		rewrites = append(rewrites, SourceRewrite{
+			start:       node.Pos(),
+			end:         node.End(),
+			replacement: expr,
+		})
+		_ = cwd
+	}
+	return rewrites, diagnostics
+}
+
+func collectTypiaSourceRewriteMap(
+	prog *driver.Program,
+	pluginOptions typiaadapter.PluginOptions,
+) (map[string][]SourceRewrite, []Diagnostic) {
+	sites := collectNestiaTypiaCallSites(prog.SourceFiles(), prog.Checker)
+	rewrites := map[string][]SourceRewrite{}
+	diagnostics := []Diagnostic{}
+	for _, site := range sites {
+		file := filepath.ToSlash(site.FilePath)
+		if reason := typiaadapter.UnsupportedReason(site); reason != "" {
+			diagnostics = append(diagnostics, NewDiagnostic(site, reason))
+			continue
+		}
+		expr, handled, err := typiaadapter.EmitCallWithOptionsPreservingTypes(prog, site, pluginOptions)
+		if !handled {
+			diagnostics = append(diagnostics, NewDiagnostic(site, "method not covered"))
+			continue
+		}
+		if err != nil {
+			diagnostics = append(diagnostics, NewDiagnostic(site, err.Error()))
+			continue
+		}
+		expr = parenthesizeTypiaReplacement(site, expr)
+		node := site.Call.AsNode()
+		rewrites[file] = append(rewrites[file], SourceRewrite{
+			start:       node.Pos(),
+			end:         node.End(),
+			replacement: expr,
+		})
+	}
+	return rewrites, diagnostics
+}
+
+func ApplySourceRewrites(source string, rewrites []SourceRewrite) (string, error) {
+	sort.SliceStable(rewrites, func(i, j int) bool {
+		return rewrites[i].start > rewrites[j].start
+	})
+	for i := 0; i < len(rewrites)-1; i++ {
+		if rewrites[i+1].end > rewrites[i].start {
+			return "", fmt.Errorf("overlapping rewrites: [%d,%d) vs [%d,%d)",
+				rewrites[i+1].start, rewrites[i+1].end, rewrites[i].start, rewrites[i].end)
+		}
+	}
+	output := source
+	for _, rewrite := range rewrites {
+		if rewrite.start < 0 || rewrite.end < rewrite.start || rewrite.end > len(output) {
+			return "", fmt.Errorf("invalid rewrite range [%d,%d)", rewrite.start, rewrite.end)
+		}
+		output = output[:rewrite.start] + rewrite.replacement + output[rewrite.end:]
+	}
+	return output, nil
+}
+
+func SourceFileText(target any) (string, bool) {
+	type sourceText interface {
+		Text() string
+	}
+	file, ok := target.(sourceText)
+	if !ok {
+		return "", false
+	}
+	return file.Text(), true
+}
+
+func cleanupTypeScriptTransformText(text string) string {
+	text = cleanupTransformedText(text)
+	text = normalizeParenthesizedTypeAnnotations(text)
+	text = regexp.MustCompile(`(?m)^import type \{([^{}\n]+)\} from`).ReplaceAllStringFunc(text, func(line string) string {
+		return regexp.MustCompile(`^import type \{\s*([^{}\n]+?)\s*\} from`).ReplaceAllString(line, "import type { $1 } from")
+	})
+	text = regexp.MustCompile(`(?m)(^import [^\n]+;\n)\n+(const |let |var |export )`).ReplaceAllString(text, "$1$2")
+	text = strings.ReplaceAll(text, "=(() =>", "= (() =>")
+	text = strings.ReplaceAll(text, ": (any) =>", ": any =>")
+	text = strings.ReplaceAll(text, ": (boolean) =>", ": boolean =>")
+	text = regexp.MustCompile(`input is \(([A-Za-z_$][A-Za-z0-9_$.]*)\)`).ReplaceAllString(text, "input is $1")
+	text = strings.ReplaceAll(text, "return (success ? ", "return success ? ")
+	text = strings.ReplaceAll(text, "}) as any;", "} as any;")
+	text = strings.ReplaceAll(text, "(() => {\n    const ", "(() => { const ")
+	text = strings.ReplaceAll(text, "(() => {\n    let ", "(() => { let ")
+	text = strings.ReplaceAll(text, "(() => {\n    return ", "(() => { return ")
+	text = strings.ReplaceAll(text, ";\n    const ", "; const ")
+	text = strings.ReplaceAll(text, ";\n    let ", "; let ")
+	text = strings.ReplaceAll(text, ";\n    return ", "; return ")
+	text = strings.ReplaceAll(text, "\n    };\n})()", "\n}; })()")
+	text = strings.ReplaceAll(text, "\n    });\n})()", "\n}); })()")
+	text = strings.ReplaceAll(text, "\n    }); let ", "\n}); let ")
+	text = strings.ReplaceAll(text, ";\n})()", "; })()")
+	text = strings.ReplaceAll(text, "\n        ", "\n    ")
+	text = regexp.MustCompile(`\n\n([A-Za-z_$][A-Za-z0-9_$]*\([^;\n]*\);?)`).ReplaceAllString(text, "\n$1")
+	trimmed := strings.TrimRight(text, " \t\r\n")
+	if strings.HasSuffix(trimmed, ")") && !strings.HasSuffix(trimmed, ";") {
+		return trimmed + ";\n"
+	}
+	if text != "" && !strings.HasSuffix(text, "\n") {
+		return text + "\n"
+	}
+	return text
+}
+
+func normalizeParenthesizedTypeAnnotations(text string) string {
+	typeAtom := `([A-Za-z_$][A-Za-z0-9_$.]*(<[^()\n;{}]*>)?)`
+	text = regexp.MustCompile(`: \(`+typeAtom+`\)(\s*=>)`).ReplaceAllString(text, ": $1$3")
+	text = regexp.MustCompile(`\| \((null|undefined)\)`).ReplaceAllString(text, "| $1")
+	return text
+}
+
+func sourceFileKey(cwd string, file string) string {
+	rel, err := filepath.Rel(cwd, filepath.FromSlash(file))
+	if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
+		return filepath.ToSlash(file)
+	}
+	return filepath.ToSlash(rel)
+}
+
+func newTransformCompilerDiagnostic(
+	file string,
+	code string,
+	message string,
+) transformCompilerDiagnostic {
+	var ptr *string
+	if file != "" {
+		normalized := filepath.ToSlash(file)
+		ptr = &normalized
+	}
+	return transformCompilerDiagnostic{
+		File:        ptr,
+		Category:    "error",
+		Code:        code,
+		MessageText: message,
+	}
+}
+
+func transformDiagnosticToCompilerDiagnostic(
+	diag Diagnostic,
+) transformCompilerDiagnostic {
+	var ptr *string
+	if diag.File != "" {
+		normalized := filepath.ToSlash(diag.File)
+		ptr = &normalized
+	}
+	return transformCompilerDiagnostic{
+		File:        ptr,
+		Category:    "error",
+		Code:        diag.Code,
+		Line:        diag.Line,
+		Character:   diag.Column,
+		MessageText: diag.Message,
+	}
+}