typia 13.1.0 → 13.1.19

package/native/cmd/ttsc-typia/transform_plugin_options_come_from_payload_test.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestTransformPluginOptionsComeFromPayload verifies the transform host takes
+// typia's options from ttsc's resolved plugin entry, not from tsconfig text.
+//
+// This host owns its own `--plugins-json` flag and its own option read, so it
+// needs its own proof: the build host passing does not show that this one is
+// wired. Every row writes a tsconfig whose raw text disagrees with the resolved
+// entry, which is exactly what samchon/typia#1887 could not tell apart -- the
+// old reader regex-matched option names over the leaf file's bytes, so it
+// enabled options the user had commented out, adopted a sibling plugin's
+// options, and ignored options inherited through `extends`.
+//
+//  1. Materialize each matrix row as a project plus the payload ttsc resolves it into.
+//  2. Run the transform host over it.
+//  3. Assert the emitted validator honors the entry, not the file text.
+func TestTransformPluginOptionsComeFromPayload(t *testing.T) {
+  for _, tc := range pluginOptionsPayloadCases() {
+    t.Run(tc.name, func(t *testing.T) {
+      project := pluginOptionsPayloadProject(t, tc)
+      out, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", "ts",
+          // `=`-joined, the exact shape ttsc's createNativeBuildArgs and the
+          // wasm hosts put on the wire.
+          "--plugins-json=" + tc.payload,
+        })
+      })
+      if code != 0 {
+        t.Fatalf("transform failed with code %d\nstdout=%s\nstderr=%s", code, out, errText)
+      }
+      pluginOptionsPayloadAssert(t, tc, out)
+    })
+  }
+}

package/native/cmd/ttsc-typia/transform_single_file_failure_atomicity_test.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "reflect"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileFailurePreservesArtifacts verifies single-file atomicity.
+//
+// The project host returns 3 when typia's analysis produced diagnostics, but both
+// single-file hosts used to publish `--out` and exit 0 regardless, shipping the
+// untransformed `typia.is<T>(input)` call behind a success code. Publication must
+// follow the same decision as the exit code in both output modes, and a failed
+// transform must not destroy an artifact a previous run left behind.
+//
+//  1. Seed `--out` with a byte-sensitive prior artifact beside an unrelated file.
+//  2. Run the single-file transform over a typia-invalid source in `ts` and `js`.
+//  3. Require exit 3, the diagnostic on stderr, and a byte-identical output tree.
+//  4. Require a fresh `--out` parent to stay uncreated, since publishing nothing
+//     must also mean creating no directory for it.
+func TestTransformSingleFileFailurePreservesArtifacts(t *testing.T) {
+  for _, output := range []string{"ts", "js"} {
+    t.Run(output, func(t *testing.T) {
+      project := transformSingleFileProject(t, transformDiagnosticSource)
+      dist := filepath.Join(project, "dist")
+      outPath := filepath.Join(dist, "main."+output)
+      seeds := map[string]string{
+        outPath:                         "previous artifact\n",
+        filepath.Join(dist, "keep.txt"): "unrelated output\n",
+      }
+      for path, body := range seeds {
+        if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+          t.Fatalf("mkdir seed parent: %v", err)
+        }
+        if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+          t.Fatalf("write seed %s: %v", path, err)
+        }
+      }
+      before := buildReadTree(t, dist)
+
+      _, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", output,
+          "--out", outPath,
+        })
+      })
+      if code != 3 {
+        t.Fatalf("invalid single-file transform should fail with code 3, got %d\nstderr=%s", code, errText)
+      }
+      normalized := filepath.ToSlash(errText)
+      if !strings.Contains(normalized, "src/main.ts:3:9 - error TS(typia.is):") ||
+        !strings.Contains(normalized, "non-specified generic argument") {
+        t.Fatalf("single-file diagnostic did not preserve location/code/message:\n%s", errText)
+      }
+      if after := buildReadTree(t, dist); !reflect.DeepEqual(after, before) {
+        t.Fatalf("failed single-file transform mutated output tree:\nbefore=%q\nafter=%q", before, after)
+      }
+
+      // writeSingleOutput mkdirs its parent, so a guard placed after publication
+      // would leave the directory behind even with no artifact in it.
+      fresh := filepath.Join(project, "fresh", "nested")
+      _, _, code = ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", output,
+          "--out", filepath.Join(fresh, "main."+output),
+        })
+      })
+      if code != 3 {
+        t.Fatalf("invalid single-file transform should fail with code 3, got %d", code)
+      }
+      if _, err := os.Stat(filepath.Join(project, "fresh")); !os.IsNotExist(err) {
+        t.Fatalf("failed single-file transform created the --out directory: %v", err)
+      }
+    })
+  }
+}
+
+// transformSingleFileProject writes a one-source project whose `src/main.ts`
+// carries the given body, sharing the typia stub the other transform diagnostic
+// fixtures use.
+func transformSingleFileProject(t *testing.T, source string) string {
+  t.Helper()
+  project := t.TempDir()
+  src := filepath.Join(project, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(project, "tsconfig.json"), []byte(transformDiagnosticTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  transformDiagnosticWriteTypiaStub(t, project)
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return project
+}
+
+// transformSingleFileValidSource is the negative twin of
+// transformDiagnosticSource: the same call shape with a resolved generic
+// argument, which typia can lower without a diagnostic.
+const transformSingleFileValidSource = `import typia from "typia";
+export function check(input: unknown): boolean {
+  return typia.is<{ value: number }>(input);
+}
+`

package/native/cmd/ttsc-typia/transform_single_file_failure_writes_no_stdout_test.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileFailureWritesNoStdout verifies the stdout publication path.
+//
+// Without `--out` the artifact is stdout, so withholding a file is not enough:
+// the untransformed source must not reach the stream a caller pipes into a file.
+// This is also the shape the wasm host reaches through `jsTransform`, whose
+// `{ code, stdout, stderr }` response is exactly these three values.
+//
+//  1. Transform a typia-invalid source in `ts` and `js` with no `--out`.
+//  2. Require exit 3 and the diagnostic on stderr.
+//  3. Require stdout to be empty rather than carrying the untransformed call.
+func TestTransformSingleFileFailureWritesNoStdout(t *testing.T) {
+  for _, output := range []string{"ts", "js"} {
+    t.Run(output, func(t *testing.T) {
+      project := transformSingleFileProject(t, transformDiagnosticSource)
+      outText, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", output,
+        })
+      })
+      if code != 3 {
+        t.Fatalf("invalid single-file transform should fail with code 3, got %d\nstdout=%s\nstderr=%s", code, outText, errText)
+      }
+      if !strings.Contains(errText, "error TS(typia.is):") {
+        t.Fatalf("single-file diagnostic missing from stderr:\n%s", errText)
+      }
+      // Before the fix this carried the untransformed `typia.is<T>(input)` call.
+      if outText != "" {
+        t.Fatalf("failed single-file transform published an artifact on stdout:\n%s", outText)
+      }
+    })
+  }
+}

package/native/cmd/ttsc-typia/transform_single_file_js_distinguishes_same_basename_sources_test.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileJSDistinguishesSameBasenameSources verifies the
+// collision boundary of the `--output js` artifact match.
+//
+// The comment on the old whole-path-stem match named the intended repair --
+// "match on basename stem" -- and a basename match would indeed have unblocked
+// `outDir`. It would also have made `src/alpha/main.ts` and `src/beta/main.ts`
+// indistinguishable, so whichever emitted `main.js` arrived last would win and
+// the command would publish another file's validator under an exit 0. Resolving
+// the expected output path through the compiler keeps the two apart by
+// construction, since they resolve to different artifacts.
+//
+//  1. Give one project two sources that share a basename in different
+//     directories, each lowering a differently shaped validator.
+//  2. Transform each with `--output js --out` under a `rootDir`/`outDir` layout.
+//  3. Require each published artifact to carry its own validator and not its
+//     namesake's.
+func TestTransformSingleFileJSDistinguishesSameBasenameSources(t *testing.T) {
+  const alphaSource = `import typia from "typia";
+export function check(input: unknown): boolean {
+  return typia.is<{ alpha: number }>(input);
+}
+`
+  const betaSource = `import typia from "typia";
+export function check(input: unknown): boolean {
+  return typia.is<{ beta: string }>(input);
+}
+`
+  project := transformSingleFileLayoutProject(
+    t,
+    []string{`"rootDir": "src"`, `"outDir": "dist"`},
+    map[string]string{
+      "src/alpha/main.ts": alphaSource,
+      "src/beta/main.ts":  betaSource,
+    },
+  )
+  for _, probe := range []struct {
+    name    string
+    file    string
+    carries string
+    rejects string
+  }{
+    {name: "alpha", file: "src/alpha/main.ts", carries: "alpha", rejects: "beta"},
+    {name: "beta", file: "src/beta/main.ts", carries: "beta", rejects: "alpha"},
+  } {
+    t.Run(probe.name, func(t *testing.T) {
+      outPath := filepath.Join(project, "artifact", probe.name+".js")
+      _, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.FromSlash(probe.file),
+          "--output", "js",
+          "--out", outPath,
+        })
+      })
+      if code != 0 {
+        t.Fatalf("`--output js` should publish %s, got %d\nstderr=%s", probe.file, code, errText)
+      }
+      data, err := os.ReadFile(outPath)
+      if err != nil {
+        t.Fatalf("`--output js` published no artifact for %s: %v", probe.file, err)
+      }
+      text := string(data)
+      if !strings.Contains(text, probe.carries) {
+        t.Fatalf("published artifact does not carry %s's validator:\n%s", probe.file, text)
+      }
+      if strings.Contains(text, probe.rejects) {
+        t.Fatalf("published artifact carries the same-basename sibling's validator:\n%s", text)
+      }
+    })
+  }
+}

package/native/cmd/ttsc-typia/transform_single_file_js_empty_emit_reports_no_output_test.go

@@ -0,0 +1,100 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileJSEmptyEmitReportsNoOutput verifies the negative twin
+// of the `--output js` artifact match.
+//
+// Teaching the match where an `outDir` puts an artifact must not turn it into a
+// match that always succeeds. "No output produced" is a real outcome: a source
+// can belong to the program and still have no JavaScript of its own, and the
+// caller needs exit 3 rather than an empty file behind exit 0. Every probe puts
+// a real artifact for a sibling source through the same write callback, so a
+// check that stopped discriminating would capture that neighbor and report
+// success. The three probes reach the outcome by different routes -- an emit
+// that skips the file, an emit that withholds it, and a file the resolution
+// gives no output path at all -- so no one of them stands in for the others.
+//
+//  1. Ask for the JavaScript of a declaration source, which the emit skips.
+//  2. Ask for the JavaScript of a source outside `rootDir`, whose output would
+//     land outside `outDir` and is therefore withheld by the emit.
+//  3. Ask for the JavaScript of a JSON module that would be emitted over
+//     itself, which resolves to no JavaScript output path.
+//  4. Require exit 3, the "no output produced" report, and an unwritten `--out`
+//     in all three.
+func TestTransformSingleFileJSEmptyEmitReportsNoOutput(t *testing.T) {
+  for _, probe := range []struct {
+    name    string
+    extra   []string
+    sources map[string]string
+    file    string
+  }{
+    // A declaration source is in the program but never emitted, so no write
+    // ever arrives for the path it resolves to.
+    {
+      name:  "declaration_source",
+      extra: []string{`"rootDir": "src"`, `"outDir": "dist"`},
+      sources: map[string]string{
+        "src/types.d.ts": "export declare const value: string;\n",
+        "src/main.ts":    transformSingleFileValidSource,
+      },
+      file: "src/types.d.ts",
+    },
+    // A source outside `rootDir` resolves to an output outside `outDir`, which
+    // the emit refuses to write rather than escaping the output tree. The
+    // source is ordinary TypeScript that transforms fine, so only the absent
+    // write distinguishes it -- exactly the state the check exists to report.
+    {
+      name:  "output_escapes_out_dir",
+      extra: []string{`"rootDir": "src/deep"`, `"outDir": "dist"`},
+      sources: map[string]string{
+        "src/deep/main.ts": transformSingleFileValidSource,
+        "src/stray.ts":     transformSingleFileValidSource,
+      },
+      file: "src/stray.ts",
+    },
+    // A JSON module with no `outDir` would be emitted over its own source, so
+    // the compiler resolves it to no JavaScript output path at all. This is the
+    // one route that reaches the empty-path guard rather than an absent write.
+    {
+      name:  "json_module_emitted_over_itself",
+      extra: []string{`"resolveJsonModule": true`},
+      sources: map[string]string{
+        "src/data.json": "{ \"value\": 1 }\n",
+        "src/main.ts":   "import data from \"./data.json\";\nexport const value = data.value;\n",
+      },
+      file: "src/data.json",
+    },
+  } {
+    t.Run(probe.name, func(t *testing.T) {
+      project := transformSingleFileLayoutProject(t, probe.extra, probe.sources)
+      outPath := filepath.Join(project, "artifact", "main.js")
+      _, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.FromSlash(probe.file),
+          "--output", "js",
+          "--out", outPath,
+        })
+      })
+      if code != 3 {
+        t.Fatalf("an empty emit must still fail with code 3, got %d\nstderr=%s", code, errText)
+      }
+      if !strings.Contains(errText, "no output produced") {
+        t.Fatalf("an empty emit must still report the cause:\n%s", errText)
+      }
+      // An empty emit leaves runTransformSingle through `if code != 0`, a
+      // different branch than the diagnostic route the atomicity case pins, so
+      // withholding the artifact needs its own check here.
+      if _, err := os.Stat(outPath); !os.IsNotExist(err) {
+        t.Fatalf("an empty emit must publish nothing, but --out exists: %v", err)
+      }
+    })
+  }
+}

package/native/cmd/ttsc-typia/transform_single_file_js_locates_output_across_layouts_test.go

@@ -0,0 +1,160 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileJSLocatesOutputAcrossLayouts verifies `--output js`
+// finds its artifact wherever the compiler places the emit.
+//
+// `transformSingleToJavaScript` captures the emit by matching the write callback
+// against the requested source. Comparing whole path stems made that match ask
+// whether `dist/main` equals `src/main`, so every project with an `outDir` --
+// which is every realistic layout -- reported "no output produced" and exited 3
+// over a transform that had in fact succeeded (samchon/typia#2134). `outDir` is
+// only one of the settings that reposition an emit, so this pins the whole class
+// rather than the reported witness: the match must come from the compiler's own
+// output-path resolution, the same one the emitter uses to choose where to
+// write, so no combination of `outDir`, `rootDir`, `rootDirs`, or source nesting
+// can desynchronize the two.
+//
+//  1. Build the same typia-valid source under each output-path layout.
+//  2. Transform it with `--output js --out`.
+//  3. Require exit 0, a silent stderr, and a published artifact carrying the
+//     lowered validator rather than the untransformed call.
+func TestTransformSingleFileJSLocatesOutputAcrossLayouts(t *testing.T) {
+  for _, layout := range []struct {
+    name  string
+    extra []string
+    file  string
+  }{
+    // The reported regression. With no `rootDir` the common source directory is
+    // the tsconfig's own directory, so the emit lands at `dist/src/main.js`.
+    {
+      name:  "out_dir",
+      extra: []string{`"outDir": "dist"`},
+      file:  "src/main.ts",
+    },
+    // `rootDir` re-bases the emit again, to `dist/main.js`, so a fix keyed on
+    // `outDir` alone would still put the artifact somewhere else than expected.
+    {
+      name:  "root_dir_and_out_dir",
+      extra: []string{`"rootDir": "src"`, `"outDir": "dist"`},
+      file:  "src/main.ts",
+    },
+    // Nesting below the root dir carries into the output as `dist/deep/nested/
+    // main.js`: the emitted path differs from the source path in more than its
+    // leading directory.
+    {
+      name:  "nested_source_directory",
+      extra: []string{`"rootDir": "src"`, `"outDir": "dist"`},
+      file:  "src/deep/nested/main.ts",
+    },
+    // `rootDirs` is a module-resolution feature and must not reposition the
+    // emit. Pin that the resolution agrees instead of assuming it.
+    {
+      name:  "root_dirs_and_out_dir",
+      extra: []string{`"rootDirs": ["src", "generated"]`, `"outDir": "dist"`},
+      file:  "src/main.ts",
+    },
+    // One source, three writes through the one callback: `dist/main.js`,
+    // `dist/main.js.map`, and `dist/main.d.ts`. Finding the artifact is not
+    // enough here -- the check has to tell it apart from its own siblings. The
+    // map is the trap, since its `sourcesContent` embeds the original
+    // TypeScript, so capturing it would publish text still carrying
+    // `typia.is<` behind exit 0.
+    {
+      name: "declaration_and_source_map",
+      extra: []string{
+        `"rootDir": "src"`,
+        `"outDir": "dist"`,
+        `"declaration": true`,
+        `"sourceMap": true`,
+      },
+      file: "src/main.ts",
+    },
+    // The one layout that already worked, because the emit lands beside its
+    // source. It must keep working.
+    {
+      name:  "no_out_dir",
+      extra: nil,
+      file:  "src/main.ts",
+    },
+  } {
+    t.Run(layout.name, func(t *testing.T) {
+      project := transformSingleFileLayoutProject(t, layout.extra, map[string]string{
+        layout.file: transformSingleFileValidSource,
+      })
+      outPath := filepath.Join(project, "artifact", "main.js")
+      _, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.FromSlash(layout.file),
+          "--output", "js",
+          "--out", outPath,
+        })
+      })
+      if code != 0 {
+        t.Fatalf("`--output js` should publish under this layout, got %d\nstderr=%s", code, errText)
+      }
+      if errText != "" {
+        t.Fatalf("`--output js` reported diagnostics under this layout:\n%s", errText)
+      }
+      data, err := os.ReadFile(outPath)
+      if err != nil {
+        t.Fatalf("`--output js` published no artifact: %v", err)
+      }
+      text := string(data)
+      if strings.Contains(text, "typia.is<") {
+        t.Fatalf("published artifact still carries the untransformed call:\n%s", text)
+      }
+      if !strings.Contains(text, `"number"`) {
+        t.Fatalf("published artifact does not carry the lowered validator:\n%s", text)
+      }
+    })
+  }
+}
+
+// transformSingleFileLayoutProject writes a project whose tsconfig carries the
+// given extra `compilerOptions` entries and whose sources are the given
+// project-relative slash paths, sharing the typia stub the other transform
+// fixtures use. It exists so one fixture can vary only the output-path settings.
+func transformSingleFileLayoutProject(
+  t *testing.T,
+  extra []string,
+  sources map[string]string,
+) string {
+  t.Helper()
+  project := t.TempDir()
+  options := append([]string{
+    `"target": "ES2022"`,
+    `"module": "commonjs"`,
+    `"moduleResolution": "bundler"`,
+    `"ignoreDeprecations": "6.0"`,
+    `"types": ["*"]`,
+    `"esModuleInterop": true`,
+    `"strict": true`,
+    `"skipLibCheck": true`,
+  }, extra...)
+  tsconfig := "{\n  \"compilerOptions\": {\n    " +
+    strings.Join(options, ",\n    ") +
+    "\n  },\n  \"include\": [\"src\"]\n}\n"
+  if err := os.WriteFile(filepath.Join(project, "tsconfig.json"), []byte(tsconfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  transformDiagnosticWriteTypiaStub(t, project)
+  for rel, body := range sources {
+    path := filepath.Join(project, filepath.FromSlash(rel))
+    if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+      t.Fatalf("mkdir %s: %v", rel, err)
+    }
+    if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", rel, err)
+    }
+  }
+  return project
+}

package/native/cmd/ttsc-typia/transform_single_file_success_publishes_artifact_test.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileSuccessPublishesArtifact verifies the positive twin.
+//
+// Consulting the diagnostics before publishing must not make a clean transform
+// withhold its artifact: the guard has to key on a reported diagnostic, not on
+// merely having run. This pins the success side of the same decision in both
+// output modes, including that the call was actually rewritten rather than
+// copied through as an untransformed stub.
+//
+//  1. Transform a typia-valid source with `--out` in `ts` and `js`.
+//  2. Require exit 0 and a silent stderr.
+//  3. Require the published artifact to exist and carry the lowered validator.
+func TestTransformSingleFileSuccessPublishesArtifact(t *testing.T) {
+  for _, output := range []string{"ts", "js"} {
+    t.Run(output, func(t *testing.T) {
+      project := transformSingleFileProject(t, transformSingleFileValidSource)
+      outPath := filepath.Join(project, "dist", "main."+output)
+      _, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", output,
+          "--out", outPath,
+        })
+      })
+      if code != 0 {
+        t.Fatalf("valid single-file transform should succeed, got %d\nstderr=%s", code, errText)
+      }
+      if errText != "" {
+        t.Fatalf("valid single-file transform reported diagnostics:\n%s", errText)
+      }
+      data, err := os.ReadFile(outPath)
+      if err != nil {
+        t.Fatalf("valid single-file transform published no artifact: %v", err)
+      }
+      text := string(data)
+      if strings.Contains(text, "typia.is<") {
+        t.Fatalf("published artifact still carries the untransformed call:\n%s", text)
+      }
+      if !strings.Contains(text, `"number"`) {
+        t.Fatalf("published artifact does not carry the lowered validator:\n%s", text)
+      }
+    })
+  }
+}

package/native/cmd/ttsc-typia/transform_wasm_host_argv_reports_diagnostics_test.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformWasmHostArgvReportsDiagnostics verifies the wasm host contract.
+//
+// `main_wasm.go` is `js && wasm` only, so its `jsTransform` cannot be called
+// here. It carries no decision of its own: it renders the JS options object into
+// argv via `transformArgs`, hands that to this same `runTransform`, and returns
+// the resulting `{ code, stdout, stderr }`. Driving the exact argv it builds --
+// `--cwd=`/`--tsconfig=`/`--file=` with its `--output=ts` default -- therefore
+// pins what a playground caller observes: the typia error, not a stub.
+//
+//  1. Build the argv `transformArgs` produces for a single-file request.
+//  2. Run it against a typia-invalid source.
+//  3. Require code 3, the diagnostic in stderr, and no stub in stdout.
+func TestTransformWasmHostArgvReportsDiagnostics(t *testing.T) {
+  project := transformSingleFileProject(t, transformDiagnosticSource)
+  argv := []string{
+    "--cwd=" + project,
+    "--tsconfig=tsconfig.json",
+    "--file=" + filepath.Join(project, "src", "main.ts"),
+    "--output=ts",
+  }
+  outText, errText, code := ttscTypiaTestCapture(func() int { return runTransform(argv) })
+  if code != 3 {
+    t.Fatalf("wasm host argv should surface code 3, got %d\nstdout=%s\nstderr=%s", code, outText, errText)
+  }
+  if !strings.Contains(errText, "non-specified generic argument") {
+    t.Fatalf("wasm host argv did not surface the typia diagnostic:\n%s", errText)
+  }
+  if outText != "" {
+    t.Fatalf("wasm host argv returned an untransformed stub as stdout:\n%s", outText)
+  }
+}