typia 13.1.1 → 13.1.19

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

@@ -0,0 +1,112 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesStarBarrelTransform verifies a barrel reached through
+// `export *` registers, even though no local specifier names the type.
+//
+// A named re-export publishes an export specifier the alias walk can step
+// through hop by hop; `export * from "./alpha"` publishes none, so that walk
+// has nothing to follow and would stop before reporting the barrel — while
+// re-pointing the star at another module still changes the generated validator
+// (samchon/typia#2126). The walk therefore reports each module specifier's
+// resolved file directly, which is what keeps this shape covered.
+//
+//  1. Build a project where `a.ts` validates `Alpha` imported from `barrel.ts`,
+//     which reaches it only through `export * from "./alpha"`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains the star barrel `barrel.ts`
+//     and the concrete module `alpha.ts`.
+//  4. Assert it does NOT contain `beta.ts`, a module the same barrel also stars
+//     in but no consulted type reaches.
+func TestProjectDependenciesStarBarrelTransform(t *testing.T) {
+  project := projectDependenciesStarBarrelProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the star barrel src/barrel.ts: %v", entries)
+  }
+  if !found["src/alpha.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the concrete module src/alpha.ts: %v", entries)
+  }
+  if found["src/beta.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/beta.ts, which the barrel stars in but no consulted type reaches: %v", entries)
+  }
+}
+
+func projectDependenciesStarBarrelProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-star-barrel-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts":      projectDependenciesStarBarrelSourceA,
+    "barrel.ts": projectDependenciesStarBarrelSourceBarrel,
+    "alpha.ts":  projectDependenciesStarBarrelSourceAlpha,
+    "beta.ts":   projectDependenciesStarBarrelSourceBeta,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesStarBarrelSourceA = `import typia from "typia";
+
+import { Alpha } from "./barrel";
+
+export const validateAlpha = (input: unknown) => typia.validate<Alpha>(input);
+`
+
+const projectDependenciesStarBarrelSourceBarrel = `export * from "./alpha";
+export * from "./beta";
+`
+
+const projectDependenciesStarBarrelSourceAlpha = `export interface Alpha {
+  id: string;
+}
+`
+
+const projectDependenciesStarBarrelSourceBeta = `export interface Beta {
+  flag: boolean;
+}
+`

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

@@ -0,0 +1,190 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectReferenceGraphEnvelopeTransform verifies the project transform
+// envelope carries the ttsc driver SDK's host-owned reference `graph` section
+// alongside typia's precise `dependencies`.
+//
+// `graph` is the plugin-agnostic sound invalidation baseline: the ttsc consumer
+// registers reach(edges, F) ∪ globals ∪ configs ∪ dependencies[F], so a
+// consulted file the precise `dependencies` collection might not attribute is
+// still guarded by the host baseline (samchon/typia#2107). This pins that
+// typia's hand-rolled envelope now routes through driver.NewTransformGraph:
+// direct reference edges (type-only included), ambient global-scope files, and
+// the tsconfig `extends` chain, all keyed by the same driver.TransformOutputKey
+// convention as the `typescript`/`dependencies` sections so a consumer joins
+// them by key.
+//
+//  1. Build a project where `a.ts` imports `Bee` from `b.ts` (and calls
+//     `typia.validate<Bee>()`), `b.ts` imports type-only `Cee` from `c.ts`, an
+//     ambient `globals.d.ts` contributes a global augmentation, and
+//     `tsconfig.json` extends `tsconfig.base.json`.
+//  2. Run project transform mode and decode the JSON envelope's `graph`.
+//  3. Assert the `a.ts -> b.ts` and the type-only `b.ts -> c.ts` edges, the
+//     `globals.d.ts` global entry, and the `tsconfig.json` + `tsconfig.base.json`
+//     configs chain, all under keys that join with the `typescript` section.
+//  4. Assert `dependencies` is still emitted next to `graph`, and that a
+//     non-global source is not misreported as a global.
+func TestProjectReferenceGraphEnvelopeTransform(t *testing.T) {
+  project := projectReferenceGraphEnvelopeProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    TypeScript map[string]string `json:"typescript"`
+    Graph      *struct {
+      Edges   map[string][]string `json:"edges"`
+      Globals []string            `json:"globals"`
+      Configs []string            `json:"configs"`
+    } `json:"graph"`
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  if envelope.Graph == nil {
+    t.Fatalf("envelope must carry a graph section:\n%s", out)
+  }
+  if _, ok := envelope.TypeScript["src/a.ts"]; !ok {
+    t.Fatalf("typescript map must contain src/a.ts (graph keys join with it):\n%s", out)
+  }
+
+  contains := func(values []string, want string) bool {
+    for _, value := range values {
+      if value == want {
+        return true
+      }
+    }
+    return false
+  }
+
+  // Direct resolved edge from the transformed file to its import.
+  if !contains(envelope.Graph.Edges["src/a.ts"], "src/b.ts") {
+    t.Fatalf("graph edges of src/a.ts must contain src/b.ts: %v", envelope.Graph.Edges["src/a.ts"])
+  }
+  // Type-only edges must be included: b.ts imports Cee with `import type`.
+  if !contains(envelope.Graph.Edges["src/b.ts"], "src/c.ts") {
+    t.Fatalf("graph edges of src/b.ts must contain the type-only edge src/c.ts: %v", envelope.Graph.Edges["src/b.ts"])
+  }
+  // Ambient global-scope file appears in globals.
+  if !contains(envelope.Graph.Globals, "src/globals.d.ts") {
+    t.Fatalf("graph globals must contain src/globals.d.ts: %v", envelope.Graph.Globals)
+  }
+  // A plain module source is not a global-scope contributor.
+  if contains(envelope.Graph.Globals, "src/c.ts") {
+    t.Fatalf("graph globals must not contain the module source src/c.ts: %v", envelope.Graph.Globals)
+  }
+  // tsconfig extends chain: project config followed by its base.
+  if !contains(envelope.Graph.Configs, "tsconfig.json") {
+    t.Fatalf("graph configs must contain tsconfig.json: %v", envelope.Graph.Configs)
+  }
+  if !contains(envelope.Graph.Configs, "tsconfig.base.json") {
+    t.Fatalf("graph configs must contain the extended tsconfig.base.json: %v", envelope.Graph.Configs)
+  }
+
+  // The precise dependencies channel remains emitted alongside graph.
+  if !contains(envelope.Dependencies["src/a.ts"], "src/b.ts") {
+    t.Fatalf("dependencies of src/a.ts must still be emitted alongside graph: %v", envelope.Dependencies["src/a.ts"])
+  }
+}
+
+func projectReferenceGraphEnvelopeProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-reference-graph-envelope-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  files := map[string]string{
+    "tsconfig.json":      projectReferenceGraphEnvelopeTSConfig,
+    "tsconfig.base.json": projectReferenceGraphEnvelopeTSConfigBase,
+  }
+  for name, body := range files {
+    if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  for name, body := range map[string]string{
+    "a.ts":         projectReferenceGraphEnvelopeSourceA,
+    "b.ts":         projectReferenceGraphEnvelopeSourceB,
+    "c.ts":         projectReferenceGraphEnvelopeSourceC,
+    "globals.d.ts": projectReferenceGraphEnvelopeGlobals,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectReferenceGraphEnvelopeTSConfig = `{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`
+
+const projectReferenceGraphEnvelopeTSConfigBase = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  }
+}
+`
+
+const projectReferenceGraphEnvelopeSourceA = `import typia from "typia";
+
+import { Bee } from "./b";
+
+export const validateBee = (input: unknown) => typia.validate<Bee>(input);
+`
+
+const projectReferenceGraphEnvelopeSourceB = `import type { Cee } from "./c";
+
+export interface Bee {
+  id: string;
+  nested: Cee;
+}
+`
+
+const projectReferenceGraphEnvelopeSourceC = `export interface Cee {
+  value: number;
+}
+`
+
+// A pure ambient declaration file (no import/export) is a script file, so it
+// contributes to the global scope and must appear in graph.globals.
+const projectReferenceGraphEnvelopeGlobals = `declare interface TypiaGraphGlobal {
+  tag: string;
+}
+`

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

@@ -0,0 +1,98 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProtobufIsEncodeFiniteNumberTransform pins protobuf.isEncode against a bare
+// number leaf so a non-finite value cannot be encoded into the message (#2196).
+//
+// protobuf.isEncode forces Options.Finite on its inner `__is` guard, then emits
+// `__is(input) ? __encode(input) : null`. A protobuf double can hold NaN and
+// Infinity, so the guard is the only thing keeping them out of the wire. While
+// `is` dropped `finite`, that guard accepted NaN and the encoder wrote it; the
+// guard must now carry Number.isFinite on the number leaf. Because isEncode has no
+// separate error-path checker, the guard is the sole place the number leaf's
+// finite check can appear, so its presence in the emit is an unambiguous oracle.
+//
+//  1. Transform a `protobuf.isEncode<{ value: number }>` fixture with default options.
+//  2. Assert the emitted `__is` guards the number leaf with Number.isFinite.
+func TestProtobufIsEncodeFiniteNumberTransform(t *testing.T) {
+  project := protobufIsEncodeFiniteNumberProject(t)
+  js := protobufIsEncodeFiniteNumberTransform(t, project)
+  needle := "Number.isFinite(input.value)"
+  if !strings.Contains(js, needle) {
+    t.Fatalf("protobuf.isEncode did not guard the number leaf with %q:\n%s", needle, js)
+  }
+}
+
+func protobufIsEncodeFiniteNumberProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "protobuf-is-encode-finite-number-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(protobufIsEncodeFiniteNumberTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(protobufIsEncodeFiniteNumberSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func protobufIsEncodeFiniteNumberTransform(t *testing.T, project string) string {
+  t.Helper()
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("protobuf isEncode finite transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+const protobufIsEncodeFiniteNumberTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const protobufIsEncodeFiniteNumberSource = `import typia from "typia";
+
+interface Box {
+  value: number;
+}
+
+export const encode = (input: unknown): Uint8Array | null =>
+  typia.protobuf.isEncode<Box>(input);
+`

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

@@ -14,47 +14,70 @@ import (
 // explicit protobuf field numbers were silently replaced by auto-numbering and
 // duplicate-sequence validation never fired.
 //
+// The two messages live in separate fixtures because a duplicate-sequence
+// diagnostic now withholds the whole file's artifact (samchon/typia#2117), so one
+// combined source could no longer show the valid message's emitted numbers.
+//
 //  1. Transform a message fixture carrying explicit `Sequence<5>` / `Sequence<7>`
 //     field numbers plus an untagged property (auto-numbered after the highest
-//     explicit number).
-//  2. Require the emitted proto message to carry the explicit numbers.
-//  3. Require a message whose two properties share `Sequence<1>` to fail the
-//     transform, leaving the call untransformed.
+//     explicit number), and require the emitted proto message to carry them.
+//  2. Require a message whose two properties share `Sequence<1>` to fail the
+//     transform with a diagnostic naming the duplicate.
+//  3. Require that rejected transform to publish no artifact.
 func TestProtobufSequenceFieldNumbersTransform(t *testing.T) {
-  project := protobufSequenceFieldNumbersProject(t)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", "js",
-    })
-  })
+  out, errText, code := protobufSequenceFieldNumbersTransform(t, "sequenced-", protobufSequenceFieldNumbersSource)
   if code != 0 {
     t.Fatalf("protobuf sequence transform failed: code=%d stderr=\n%s", code, errText)
   }
+  // The subject is the explicit `Sequence<5>` / `Sequence<7>` field numbers and
+  // the auto-numbered `8` after them; the presence label is `optional` because
+  // proto3 has no `required`, and emitting it would make the document reject
+  // under a Protobuf compiler (samchon/typia#2155). Compiler legality itself is
+  // pinned by TestProtobufMessageDocumentCompiles.
   for _, line := range []string{
-    "required string id = 5;",
-    "required double age = 7;",
-    "required bool flag = 8;",
+    "optional string id = 5;",
+    "optional double age = 7;",
+    "optional bool flag = 8;",
   } {
     if !strings.Contains(out, line) {
       t.Fatalf("emitted proto message should contain %q:\n%s", line, out)
     }
   }
-  if !strings.Contains(out, ".protobuf.message()") {
-    t.Fatalf("duplicated sequence message should stay untransformed:\n%s", out)
+
+  dupOut, dupErr, dupCode := protobufSequenceFieldNumbersTransform(t, "duplicated-", protobufSequenceDuplicatedSource)
+  if dupCode != 3 {
+    t.Fatalf("duplicated sequence message should be rejected with code 3: code=%d stdout=\n%s\nstderr=\n%s", dupCode, dupOut, dupErr)
+  }
+  if !strings.Contains(dupErr, "error TS(typia.protobuf.message):") ||
+    !strings.Contains(dupErr, `The Sequence<1> tag is duplicated in two properties ("id" and "age")`) {
+    t.Fatalf("duplicated sequence diagnostic did not name the collision:\n%s", dupErr)
   }
+  if dupOut != "" {
+    t.Fatalf("duplicated sequence message published an artifact:\n%s", dupOut)
+  }
+}
+
+func protobufSequenceFieldNumbersTransform(t *testing.T, prefix string, source string) (string, string, int) {
+  t.Helper()
+  project := protobufSequenceFieldNumbersProject(t, prefix, source)
+  return ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
 }
 
-func protobufSequenceFieldNumbersProject(t *testing.T) string {
+func protobufSequenceFieldNumbersProject(t *testing.T, prefix string, source string) string {
   t.Helper()
   root := ttscTypiaTestRepoRoot(t)
   base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
   if err := os.MkdirAll(base, 0o755); err != nil {
     t.Fatalf("mkdir temp base: %v", err)
   }
-  dir, err := os.MkdirTemp(base, "protobuf-sequence-")
+  dir, err := os.MkdirTemp(base, "protobuf-sequence-"+prefix)
   if err != nil {
     t.Fatalf("create temp fixture: %v", err)
   }
@@ -68,7 +91,7 @@ func protobufSequenceFieldNumbersProject(t *testing.T) string {
   if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(protobufSequenceFieldNumbersTSConfig), 0o644); err != nil {
     t.Fatalf("write tsconfig: %v", err)
   }
-  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(protobufSequenceFieldNumbersSource), 0o644); err != nil {
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
     t.Fatalf("write source: %v", err)
   }
   return dir
@@ -97,11 +120,18 @@ interface Sequenced {
   flag: boolean;
 }
 
+export const sequenced = typia.protobuf.message<Sequenced>();
+`
+
+// protobufSequenceDuplicatedSource is the negative twin: the same message shape
+// whose two properties claim one `Sequence<1>` number, which typia must reject
+// rather than auto-renumber.
+const protobufSequenceDuplicatedSource = `import typia, { tags } from "typia";
+
 interface Duplicated {
   id: string & tags.Sequence<1>;
   age: number & tags.Sequence<1>;
 }
 
-export const sequenced = typia.protobuf.message<Sequenced>();
 export const duplicated = typia.protobuf.message<Duplicated>();
 `