@nestia/core 12.0.0-dev.20260601.1 → 12.0.0-dev.20260612.2

package/native/transform/core_dispatch_test.go

@@ -1,127 +0,0 @@
-package transform
-
-import "testing"
-
-// Verifies nestiaCoreParameterKind maps every supported decorator suffix
-// to the programmer kind that drives validator generation.
-//
-// The suffix table is the single source of truth for parameter-decorator
-// dispatch — a silent typo or a missing entry would silently route the
-// affected decorator to the no-op path and emit no validator. The
-// `WebSocketRoute.Header`-as-`TypedBody` and `EncryptedBody`-as-`TypedBody`
-// rows are non-obvious: WebSocket header and encrypted body re-use the
-// TypedBody programmer because their on-the-wire payload shape matches.
-//
-//  1. Every documented suffix returns the matching kind.
-//  2. Multi-segment suffixes (`TypedQuery.Body`, `WebSocketRoute.Param`)
-//     resolve only when both tail segments line up.
-//  3. Unknown suffixes return the empty string (the no-op signal).
-func TestNestiaCoreParameterKindDispatch(t *testing.T) {
-	cases := []struct {
-		name     string
-		segments []string
-		want     string
-	}{
-		{"bare TypedBody", []string{"TypedBody"}, "TypedBody"},
-		{"imported core.TypedBody", []string{"core", "TypedBody"}, "TypedBody"},
-		{"EncryptedBody maps to TypedBody", []string{"EncryptedBody"}, "TypedBody"},
-		{"TypedHeaders", []string{"TypedHeaders"}, "TypedHeaders"},
-		{"TypedParam", []string{"TypedParam"}, "TypedParam"},
-		{"TypedQuery solo", []string{"TypedQuery"}, "TypedQuery"},
-		{"PlainBody", []string{"PlainBody"}, "PlainBody"},
-		{"TypedQuery.Body", []string{"TypedQuery", "Body"}, "TypedQueryBody"},
-		{"TypedFormData.Body", []string{"TypedFormData", "Body"}, "TypedFormDataBody"},
-		{"WebSocketRoute.Header maps to TypedBody", []string{"WebSocketRoute", "Header"}, "TypedBody"},
-		{"WebSocketRoute.Param maps to TypedParam", []string{"WebSocketRoute", "Param"}, "TypedParam"},
-		{"WebSocketRoute.Query maps to TypedQuery", []string{"WebSocketRoute", "Query"}, "TypedQuery"},
-		{"unknown decorator", []string{"TypedSomethingElse"}, ""},
-		{"empty segments", []string{}, ""},
-		{"TypedQuery.Other is not TypedQueryBody", []string{"TypedQuery", "Other"}, ""},
-		{"WebSocketRoute alone is not a parameter", []string{"WebSocketRoute"}, ""},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := nestiaCoreParameterKind(tc.segments); got != tc.want {
-				t.Fatalf("nestiaCoreParameterKind(%v) = %q, want %q", tc.segments, got, tc.want)
-			}
-		})
-	}
-}
-
-// Verifies nestiaCoreMethodKind dispatches HTTP-method decorators to the
-// correct route programmer kind.
-//
-// The two-position lookup (`[..., ROOT, VERB]`) keeps `EncryptedRoute.Post`
-// distinct from `TypedQuery.Body` — both have two tail segments but only
-// the former is a route. The verb whitelist (Get/Post/Patch/Put/Delete)
-// pins the contract: any new HTTP verb would have to be added explicitly,
-// preventing accidental dispatch on a typo like `Posts`.
-//
-//  1. Each HTTP verb under `TypedRoute` or `EncryptedRoute` returns `TypedRoute`.
-//  2. Each HTTP verb under `TypedQuery` returns `TypedQueryRoute`.
-//  3. Unknown roots or unknown verbs return the empty string.
-//  4. Single-segment or empty segment lists return the empty string.
-func TestNestiaCoreMethodKindDispatch(t *testing.T) {
-	cases := []struct {
-		name     string
-		segments []string
-		want     string
-	}{
-		{"TypedRoute.Get", []string{"TypedRoute", "Get"}, "TypedRoute"},
-		{"TypedRoute.Post", []string{"TypedRoute", "Post"}, "TypedRoute"},
-		{"TypedRoute.Patch", []string{"TypedRoute", "Patch"}, "TypedRoute"},
-		{"TypedRoute.Put", []string{"TypedRoute", "Put"}, "TypedRoute"},
-		{"TypedRoute.Delete", []string{"TypedRoute", "Delete"}, "TypedRoute"},
-		{"EncryptedRoute.Post", []string{"EncryptedRoute", "Post"}, "TypedRoute"},
-		{"TypedQuery.Get", []string{"TypedQuery", "Get"}, "TypedQueryRoute"},
-		{"imported core.TypedRoute.Get", []string{"core", "TypedRoute", "Get"}, "TypedRoute"},
-		{"unknown verb", []string{"TypedRoute", "Head"}, ""},
-		{"unknown root", []string{"SomethingElse", "Get"}, ""},
-		{"single segment", []string{"Get"}, ""},
-		{"empty segments", []string{}, ""},
-		{"verb-only suffix", []string{"TypedQuery", "Body"}, ""},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := nestiaCoreMethodKind(tc.segments); got != tc.want {
-				t.Fatalf("nestiaCoreMethodKind(%v) = %q, want %q", tc.segments, got, tc.want)
-			}
-		})
-	}
-}
-
-// Verifies nestiaCoreSegmentsHaveSuffix matches the suffix slice against
-// the trailing positions of the segment slice.
-//
-// The helper underpins every decorator-dispatch lookup. Off-by-one or
-// length-clamping bugs would silently mismatch `core.TypedQuery.Body`
-// against the suffix `["TypedQuery"]` — a regression flagged by the
-// existing decorator routing tests, but cheap to anchor at the helper
-// level too.
-//
-//  1. Exact length match returns true.
-//  2. Shorter segments than the suffix never match.
-//  3. Suffix tail of a longer segment list matches; prefix tail does not.
-func TestNestiaCoreSegmentsHaveSuffix(t *testing.T) {
-	cases := []struct {
-		name     string
-		segments []string
-		suffix   []string
-		want     bool
-	}{
-		{"exact match", []string{"TypedBody"}, []string{"TypedBody"}, true},
-		{"suffix of longer", []string{"core", "TypedBody"}, []string{"TypedBody"}, true},
-		{"two-segment suffix", []string{"core", "TypedQuery", "Body"}, []string{"TypedQuery", "Body"}, true},
-		{"suffix longer than segments", []string{"TypedBody"}, []string{"core", "TypedBody"}, false},
-		{"mismatched tail", []string{"core", "TypedBody"}, []string{"TypedRoute"}, false},
-		{"empty suffix", []string{"core", "TypedBody"}, []string{}, true},
-		{"both empty", []string{}, []string{}, true},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := nestiaCoreSegmentsHaveSuffix(tc.segments, tc.suffix); got != tc.want {
-				t.Fatalf("nestiaCoreSegmentsHaveSuffix(%v, %v) = %v, want %v", tc.segments, tc.suffix, got, tc.want)
-			}
-		})
-	}
-}

package/native/transform/path_rewrite_test.go

@@ -1,243 +0,0 @@
-package transform
-
-import "testing"
-
-// Verifies emittedJavaScriptExtension maps source-file extensions to the
-// matching JavaScript output extension that tsgo writes.
-//
-// The native rewrite scan asks for the post-emit name of every registered
-// source. A mismatch here means the rewrite searches for `.js` files when
-// the project actually emits `.mjs` (ESM packages) or `.cjs`, and the
-// "could not locate <call>" failure path then fires on legitimate
-// builds. The case-insensitive switch covers Windows-style mixed-case
-// `.MTS` paths some toolchains produce.
-//
-//  1. Cover the three explicit branches (.mts, .cts, default).
-//  2. Cover the case-insensitive variants (.MTS, .CTS).
-//  3. Cover the default fallback for unknown / extensionless inputs.
-func TestEmittedJavaScriptExtensionMapsSourceToOutput(t *testing.T) {
-	cases := []struct {
-		name   string
-		source string
-		want   string
-	}{
-		{"plain ts", "/repo/src/index.ts", ".js"},
-		{"plain tsx", "/repo/src/Component.tsx", ".js"},
-		{"esm mts", "/repo/src/index.mts", ".mjs"},
-		{"cjs cts", "/repo/src/index.cts", ".cjs"},
-		{"uppercase mts", "/repo/src/Index.MTS", ".mjs"},
-		{"uppercase cts", "/repo/src/Index.CTS", ".cjs"},
-		{"declaration only", "/repo/src/types.d.ts", ".js"},
-		{"unknown extension", "/repo/src/data.json", ".js"},
-		{"extensionless", "/repo/src/README", ".js"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := emittedJavaScriptExtension(tc.source); got != tc.want {
-				t.Fatalf("emittedJavaScriptExtension(%q) = %q, want %q", tc.source, got, tc.want)
-			}
-		})
-	}
-}
-
-// Verifies matchPattern strictly matches the literal-pattern branch and
-// returns the wildcard capture for star-bearing patterns.
-//
-// `matchPattern` underpins every `paths` resolver entry — a regression in
-// the prefix / suffix slice arithmetic would silently break tsconfig
-// `paths` aliasing for any project that uses it. The literal branch must
-// reject `pattern !== specifier`; the wildcard branch must demand BOTH
-// the prefix and suffix to anchor before extracting the capture.
-//
-//  1. Literal patterns match only on byte equality.
-//  2. Single-wildcard patterns extract the gap between prefix and suffix.
-//  3. Mismatched prefix or suffix returns no capture.
-func TestMatchPatternLiteralAndWildcardBranches(t *testing.T) {
-	cases := []struct {
-		name    string
-		pattern string
-		input   string
-		want    string
-		matched bool
-	}{
-		{"literal match", "@api", "@api", "", true},
-		{"literal mismatch", "@api", "@api/lib", "", false},
-		{"wildcard captures middle", "@api/*", "@api/users", "users", true},
-		{"wildcard captures nested", "@api/lib/*", "@api/lib/sub/file", "sub/file", true},
-		{"wildcard mismatch prefix", "@api/*", "@other/users", "", false},
-		{"wildcard mismatch suffix", "@api/*.ts", "@api/users.tsx", "", false},
-		{"wildcard between prefix and suffix", "src/*/index.ts", "src/foo/index.ts", "foo", true},
-		{"empty capture allowed", "prefix*suffix", "prefixsuffix", "", true},
-		{"second wildcard treated as literal", "@api/*/lib/*", "@api/foo/lib/*", "foo", true},
-		{"second wildcard does not expand", "@api/*/lib/*", "@api/foo/lib/bar", "", false},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got, ok := matchPattern(tc.pattern, tc.input)
-			if ok != tc.matched {
-				t.Fatalf("matchPattern(%q, %q) ok = %v, want %v", tc.pattern, tc.input, ok, tc.matched)
-			}
-			if ok && got != tc.want {
-				t.Fatalf("matchPattern(%q, %q) capture = %q, want %q", tc.pattern, tc.input, got, tc.want)
-			}
-		})
-	}
-}
-
-// Verifies patternRank assigns longer literal-character counts higher rank
-// so the longest non-wildcard pattern wins when several match.
-//
-// tsconfig `paths` resolution sorts candidates by `patternRank` descending
-// to break ties — without this ordering the resolver could pick the
-// loosest pattern over a more specific one (e.g. `*` over `@api/*`).
-//
-//  1. A pure-wildcard pattern ranks 0.
-//  2. Each non-wildcard character adds 1 regardless of position.
-//  3. Multiple wildcards do not double-count literal segments.
-func TestPatternRankCountsNonWildcardCharacters(t *testing.T) {
-	cases := []struct {
-		pattern string
-		want    int
-	}{
-		{"*", 0},
-		{"@api/*", 5},
-		{"@api/lib/*", 9},
-		{"src/*/index.ts", 13},
-		{"prefix*suffix", 12},
-	}
-	for _, tc := range cases {
-		if got := patternRank(tc.pattern); got != tc.want {
-			t.Fatalf("patternRank(%q) = %d, want %d", tc.pattern, got, tc.want)
-		}
-	}
-}
-
-// Verifies normalizePath collapses redundant POSIX separators and
-// resolves `..` segments via filepath.Clean.
-//
-// The rewrite pipeline keys outputs and sources by their normalized
-// path. A regression here would split a single logical source into
-// multiple cache entries, defeating `nativeRewriteSet`'s deduplication.
-// `filepath.ToSlash` runs after Clean — on Linux it is a no-op for
-// already-POSIX input; backslash handling is delegated to the platform.
-//
-//  1. Empty input returns empty.
-//  2. Adjacent separators collapse.
-//  3. `..` segments are resolved relative to the preceding directory.
-//  4. A leading `./` is stripped (filepath.Clean canonicalization).
-func TestNormalizePathProducesPosixSlashes(t *testing.T) {
-	cases := []struct {
-		input string
-		want  string
-	}{
-		{"", ""},
-		{"/repo/src/index.ts", "/repo/src/index.ts"},
-		{"/repo//src///index.ts", "/repo/src/index.ts"},
-		{"/repo/src/../src/index.ts", "/repo/src/index.ts"},
-		{"./relative/path", "relative/path"},
-	}
-	for _, tc := range cases {
-		if got := normalizePath(tc.input); got != tc.want {
-			t.Fatalf("normalizePath(%q) = %q, want %q", tc.input, got, tc.want)
-		}
-	}
-}
-
-// Verifies isOutsideRelativePath flags any relative path that escapes the
-// root via `..` segments.
-//
-// `pathRewriter.outputForSource` refuses to map sources that resolve
-// outside `rootDir`. Without this guard, a controller imported from a
-// monorepo neighbor would emit into the outDir at a relative position
-// that collides with an unrelated file.
-//
-//  1. Bare `..` is outside.
-//  2. `../...` prefix is outside.
-//  3. Same-or-nested paths are inside.
-func TestIsOutsideRelativePathRejectsParentEscapes(t *testing.T) {
-	cases := []struct {
-		rel  string
-		want bool
-	}{
-		{"..", true},
-		{"../sibling", true},
-		{"../../escape", true},
-		{".", false},
-		{"nested/file.ts", false},
-		{"sub/../same.ts", false},
-	}
-	for _, tc := range cases {
-		if got := isOutsideRelativePath(tc.rel); got != tc.want {
-			t.Fatalf("isOutsideRelativePath(%q) = %v, want %v", tc.rel, got, tc.want)
-		}
-	}
-}
-
-// Verifies stripKnownSourceExtension prefers the longest known suffix and
-// falls back to filepath.Ext for unknown extensions.
-//
-// The declaration-file extensions (`.d.ts`, `.d.mts`, `.d.cts`) must be
-// matched as a whole — falling through to the simpler `.ts` strip would
-// leave the `.d` suffix on the stem and silently produce wrong virtual
-// paths for declaration emitters.
-//
-//  1. `.d.ts` strips the full three-character suffix.
-//  2. Each one-extension form (`.ts`, `.tsx`, `.mts`, …) strips cleanly.
-//  3. Unknown extensions fall back to filepath.Ext.
-//  4. Case-insensitive match on uppercase variants.
-func TestStripKnownSourceExtensionPrefersLongestMatch(t *testing.T) {
-	cases := []struct {
-		input string
-		want  string
-	}{
-		{"types.d.ts", "types"},
-		{"types.d.mts", "types"},
-		{"types.d.cts", "types"},
-		{"index.ts", "index"},
-		{"index.tsx", "index"},
-		{"index.mts", "index"},
-		{"index.cts", "index"},
-		{"index.js", "index"},
-		{"data.json", "data"},
-		{"Index.D.TS", "Index"},
-		{"README", "README"},
-	}
-	for _, tc := range cases {
-		if got := stripKnownSourceExtension(tc.input); got != tc.want {
-			t.Fatalf("stripKnownSourceExtension(%q) = %q, want %q", tc.input, got, tc.want)
-		}
-	}
-}
-
-// Verifies replaceSourceExtension swaps the known TypeScript extension
-// while preserving the rest of the path.
-//
-// Combined with `emittedJavaScriptExtension`, this drives the source ↔
-// output filename mapping the rewrite scan depends on. The declaration
-// case is load-bearing: `stripKnownSourceExtension` must prefer the full
-// `.d.ts` suffix over a plain `.ts` strip, otherwise `types.d.ts +
-// .d.ts` would silently become `types..d.ts` and the declaration
-// emitter would write a corrupt path.
-//
-//  1. `.ts` is replaced with the chosen output extension.
-//  2. Declaration suffixes (`.d.ts`) strip wholly before replacement.
-//  3. POSIX separators in the input flow through unchanged.
-//  4. `.d.ts` + `.d.ts` stays `.d.ts` (pins the longest-match prefer rule).
-func TestReplaceSourceExtensionSwapsKnownSuffix(t *testing.T) {
-	cases := []struct {
-		input string
-		ext   string
-		want  string
-	}{
-		{"src/index.ts", ".js", "src/index.js"},
-		{"src/index.mts", ".mjs", "src/index.mjs"},
-		{"src/types.d.ts", ".js", "src/types.js"},
-		{"src/nested/foo.ts", ".js", "src/nested/foo.js"},
-		{"src/types.d.ts", ".d.ts", "src/types.d.ts"},
-	}
-	for _, tc := range cases {
-		if got := replaceSourceExtension(tc.input, tc.ext); got != tc.want {
-			t.Fatalf("replaceSourceExtension(%q, %q) = %q, want %q", tc.input, tc.ext, got, tc.want)
-		}
-	}
-}

package/native/transform/rewrite_test.go

@@ -1,118 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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)
-	}
-}