typia 13.1.0 → 13.1.19

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

@@ -0,0 +1,309 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNotationUnicodeKeyTransform verifies the notation emit keeps a non-ASCII
+// key intact and agrees with the runtime helper.
+//
+// Issue #2227: the emit computed each renamed key by slicing one *byte*
+// (`value[:1]`) before case-converting it, so a multi-byte rune's lead byte was
+// handed to the case operation on its own, could not be decoded, and came back
+// as U+FFFD — `typia.notations.createPascal<{ "École": number }>()` emitted the
+// key `"��cole"`. The static path corrupted the key while the dynamic
+// (index-signature) path, which calls the runtime `_notationPascal`, did not, so
+// one object could carry two different renamings of the same character and the
+// emitted key did not match its declared `CamelCase<T>` / `PascalCase<T>` type.
+//
+// The same fix covers the second half of the divergence: JavaScript performs
+// Unicode *full* case conversion while Go's `strings.ToUpper`/`ToLower` perform
+// the *simple* per-rune mapping, so the emit also disagreed with the runtime on
+// `ß` -> `SS`, `İ` -> `i` + U+0307, and the word-final sigma `ΑΣ` -> `ας`. That
+// half reached `snake`/`kebab` too, which never sliced a byte.
+//
+// Every key and every expectation below is written with `\uXXXX` escapes so the
+// fixture cannot be silently renormalized (NFC/NFD) by an editor, and so the
+// combining-mark and surrogate-pair cases stay exactly what they claim to be.
+//
+//  1. Transform a fixture whose keys cover a multi-byte first character, a
+//     multi-byte character right after an underscore, a key that is a single
+//     multi-byte character, a combining mark (NFD), a surrogate pair, and the
+//     case-folding-sensitive `İ`, `ß`, and word-final sigma — plus two ASCII
+//     keys as a regression anchor.
+//  2. Require the emitted JavaScript to carry no U+FFFD at all.
+//  3. Execute each statically emitted converter and assert its key-to-value map
+//     equals the expectation derived from JavaScript's own case semantics.
+//  4. Execute the dynamic `Record` converter, which routes through the runtime
+//     `_notation*` helper, over the same keys and require an identical map, so
+//     the compile-time emit and the runtime helper are proven equal per key.
+func TestNotationUnicodeKeyTransform(t *testing.T) {
+  project := notationUnicodeKeyProject(t)
+  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("unicode notation transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  // The printer escapes every non-ASCII code unit, so a corrupted key reaches
+  // the output as the escape text rather than as the replacement rune itself.
+  // Both forms are rejected; checking only the rune would never fire.
+  if strings.Contains(out, `\uFFFD`) || strings.ContainsRune(out, '�') {
+    t.Fatalf("emitted converter must not contain U+FFFD; a key was corrupted by byte slicing:\n%s", out)
+  }
+  // Pin the exact emitted assignments for the witnesses of each half of the
+  // defect: the multi-byte first character and the post-underscore segment that
+  // byte slicing destroyed, plus the two characters that the simple per-rune
+  // case mapping got wrong. The printer escapes every non-ASCII code unit, so
+  // these are the literal bytes of the emitted JavaScript.
+  for _, assignment := range []string{
+    `["\u00E9cole"]: input["\u00C9cole"]`,
+    `["Key\u00D6lig"]: input["key_\u00D6lig"]`,
+    `["SS"]: input["\u00DF"]`,
+    `["i\u0307stanbul"]: input["\u0130stanbul"]`,
+  } {
+    if !strings.Contains(out, assignment) {
+      t.Fatalf("emitted converter should contain the assignment %s:\n%s", assignment, out)
+    }
+  }
+  notationUnicodeKeyRunRuntimeCases(t, project, out)
+}
+
+func notationUnicodeKeyProject(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, "notation-unicode-")
+  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(notationUnicodeKeyTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(notationUnicodeKeySource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func notationUnicodeKeyRunRuntimeCases(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(notationUnicodeKeyRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  if err != nil {
+    t.Fatalf("unicode notation runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const notationUnicodeKeyTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const notationUnicodeKeySource = `import typia from "typia";
+
+interface SourceRecord {
+  "\u00C9cole": number;
+  "\u00F6lwert": number;
+  "\u65E5\u672C\u8A9E": number;
+  "key_\u00D6lig": number;
+  "\u00D6": number;
+  "\u0130stanbul": number;
+  "\u00DF": number;
+  "\uD801\uDC28test": number;
+  "\u0391\u03A3_\u0391\u03A3": number;
+  "e\u0301cole": number;
+  "\u00FCber_Stra\u00DFe": number;
+  MAX_COUNT: number;
+  fooBar: number;
+}
+
+type DynamicRecord = Record<string, number>;
+
+export const toCamel = typia.notations.createCamel<SourceRecord>();
+export const toPascal = typia.notations.createPascal<SourceRecord>();
+export const toSnake = typia.notations.createSnake<SourceRecord>();
+export const toKebab = typia.notations.createKebab<SourceRecord>();
+
+export const toCamelDynamic = typia.notations.createCamel<DynamicRecord>();
+export const toPascalDynamic = typia.notations.createPascal<DynamicRecord>();
+export const toSnakeDynamic = typia.notations.createSnake<DynamicRecord>();
+export const toKebabDynamic = typia.notations.createKebab<DynamicRecord>();
+`
+
+const notationUnicodeKeyRuntimeRunner = `const mod = require("./main.cjs");
+
+// Every source key carries a distinct value, so comparing the whole
+// key-to-value map proves the per-key renaming rather than just the key set.
+const input = {
+  ["\u00C9cole"]: 1,
+  ["\u00F6lwert"]: 2,
+  ["\u65E5\u672C\u8A9E"]: 3,
+  ["key_\u00D6lig"]: 4,
+  ["\u00D6"]: 5,
+  ["\u0130stanbul"]: 6,
+  ["\u00DF"]: 7,
+  ["\uD801\uDC28test"]: 8,
+  ["\u0391\u03A3_\u0391\u03A3"]: 9,
+  ["e\u0301cole"]: 10,
+  ["\u00FCber_Stra\u00DFe"]: 11,
+  ["MAX_COUNT"]: 12,
+  ["fooBar"]: 13,
+};
+
+// Expectations are JavaScript's own case semantics, not a snapshot of the Go
+// emit: full case conversion (ß -> SS, İ -> i + U+0307, word-final
+// sigma ΑΣ -> ας) and UTF-16 code-unit indexing, under which
+// str[0] of an astral character is an uncased lone surrogate and stays put.
+const expected = {
+  camel: {
+    ["\u00E9cole"]: 1,
+    ["\u00F6lwert"]: 2,
+    ["\u65E5\u672C\u8A9E"]: 3,
+    ["key\u00D6lig"]: 4,
+    ["\u00F6"]: 5,
+    ["i\u0307stanbul"]: 6,
+    ["\u00DF"]: 7,
+    ["\uD801\uDC28test"]: 8,
+    ["\u03B1\u03C2\u0391\u03C3"]: 9,
+    ["e\u0301cole"]: 10,
+    ["\u00FCberStra\u00DFe"]: 11,
+    ["maxCount"]: 12,
+    ["fooBar"]: 13,
+  },
+  pascal: {
+    ["\u00C9cole"]: 1,
+    ["\u00D6lwert"]: 2,
+    ["\u65E5\u672C\u8A9E"]: 3,
+    ["Key\u00D6lig"]: 4,
+    ["\u00D6"]: 5,
+    ["\u0130stanbul"]: 6,
+    ["SS"]: 7,
+    ["\uD801\uDC28test"]: 8,
+    ["\u0391\u03C3\u0391\u03C3"]: 9,
+    ["E\u0301cole"]: 10,
+    ["\u00DCberStra\u00DFe"]: 11,
+    ["MaxCount"]: 12,
+    ["FooBar"]: 13,
+  },
+  snake: {
+    ["\u00E9cole"]: 1,
+    ["\u00F6lwert"]: 2,
+    ["\u65E5\u672C\u8A9E"]: 3,
+    ["key_\u00F6lig"]: 4,
+    ["\u00F6"]: 5,
+    ["i\u0307stanbul"]: 6,
+    ["\u00DF"]: 7,
+    ["\uD801\uDC28test"]: 8,
+    ["\u03B1\u03C2_\u03B1\u03C2"]: 9,
+    ["e\u0301cole"]: 10,
+    ["\u00FCber_stra\u00DFe"]: 11,
+    ["max_count"]: 12,
+    ["foo_bar"]: 13,
+  },
+  kebab: {
+    ["\u00E9cole"]: 1,
+    ["\u00F6lwert"]: 2,
+    ["\u65E5\u672C\u8A9E"]: 3,
+    ["key-\u00F6lig"]: 4,
+    ["\u00F6"]: 5,
+    ["i\u0307stanbul"]: 6,
+    ["\u00DF"]: 7,
+    ["\uD801\uDC28test"]: 8,
+    ["\u03B1\u03C2-\u03B1\u03C2"]: 9,
+    ["e\u0301cole"]: 10,
+    ["\u00FCber-stra\u00DFe"]: 11,
+    ["max-count"]: 12,
+    ["foo-bar"]: 13,
+  },
+};
+
+const normalize = (object) =>
+  JSON.stringify(
+    Object.entries(object)
+      .map(([key, value]) => [Array.from(key, (c) => c.charCodeAt(0)), value])
+      .sort((a, b) => (String(a) < String(b) ? -1 : 1)),
+  );
+
+const notations = ["camel", "pascal", "snake", "kebab"];
+const capitalize = (name) => name[0].toUpperCase() + name.substring(1);
+
+for (const notation of notations) {
+  const want = normalize(expected[notation]);
+
+  // The statically emitted converter: one property assignment per known key.
+  const staticResult = mod["to" + capitalize(notation)](input);
+  if (normalize(staticResult) !== want) {
+    throw new Error(
+      "static " + notation + " emit disagreed with JavaScript case semantics:\n" +
+        "  expected " + want + "\n" +
+        "  actual   " + normalize(staticResult),
+    );
+  }
+
+  // The dynamic converter: one runtime _notation* call per index-signature key.
+  const dynamicResult = mod["to" + capitalize(notation) + "Dynamic"](input);
+  if (normalize(dynamicResult) !== normalize(staticResult)) {
+    throw new Error(
+      "static " + notation + " emit disagreed with the runtime helper:\n" +
+        "  runtime " + normalize(dynamicResult) + "\n" +
+        "  emit    " + normalize(staticResult),
+    );
+  }
+
+  for (const key of Object.keys(staticResult)) {
+    if (key.includes("�")) {
+      throw new Error(
+        "renamed " + notation + " key contains U+FFFD: " + JSON.stringify(key),
+      );
+    }
+  }
+}
+`

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

@@ -0,0 +1,224 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestPatternLineTerminatorEscapeTransform verifies that a line terminator in a
+// structural (template-literal-type or dynamic-key) pattern is escaped before it
+// is spliced into an emitted `RegExp(/.../)` literal.
+//
+// A JavaScript regex literal cannot contain a raw line terminator, so a template
+// literal type or dynamic key whose literal part holds one of the four
+// ECMAScript LineTerminators (LF, CR, U+2028, U+2029) produced an unparsable
+// module while the transform still exited 0 (a false-green). `PatternUtil.Escape`
+// escaped the regex metacharacters but not the line terminators, and it is the
+// single source feeding every regex-literal sink (`check_template`,
+// `stringify_dynamic_properties`, `prune_object_properties`, and the
+// clone/prune/classify/notation joiners), so one fixture that drives `is`,
+// `json.stringify`, `clone`, `prune`, and `notations` over line-terminator
+// patterns exercises them all (#2211).
+//
+//  1. Transform a fixture whose template literal types and Record dynamic keys
+//     carry each of the four line terminators, across every affected operation.
+//  2. Assert the transform exits 0 and `node --check` accepts the whole emit as
+//     JavaScript -- RED before the fix (raw LF/CR/LS/PS in a regex literal).
+//  3. Execute the emit and assert each `is` predicate matches a
+//     line-terminator-containing value and rejects a value that lacks it.
+func TestPatternLineTerminatorEscapeTransform(t *testing.T) {
+  project := patternLineTerminatorProject(t)
+  js := patternLineTerminatorTransform(t, project)
+  // A line-terminator-free template still lowers to its historical pattern, so
+  // nothing but the escaped line terminators changes.
+  if !strings.Contains(js, "RegExp(/^prefix(.*)postfix$/)") {
+    t.Fatalf("line-terminator-free pattern must keep its historical form:\n%s", js)
+  }
+  patternLineTerminatorCheckSyntax(t, project, js)
+  patternLineTerminatorRunRuntimeCases(t, project, js)
+}
+
+func patternLineTerminatorProject(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, "pattern-line-terminator-")
+  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(patternLineTerminatorTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(patternLineTerminatorSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func patternLineTerminatorTransform(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("line terminator pattern transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+// patternLineTerminatorCheckSyntax runs node against the emit exactly as it would
+// ship. node --check only parses, so the unresolved typia imports in the
+// untouched output do not matter, which keeps this a check of the real artifact.
+func patternLineTerminatorCheckSyntax(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  emitted := filepath.Join(project, "emitted.cjs")
+  if err := os.WriteFile(emitted, []byte(js), 0o644); err != nil {
+    t.Fatalf("write emitted module: %v", err)
+  }
+  if output, err := exec.Command(node, "--check", emitted).CombinedOutput(); err != nil {
+    t.Fatalf("emitted module is not valid JavaScript: %v\n%s\n--- emit ---\n%s", err, output, js)
+  }
+}
+
+func patternLineTerminatorRunRuntimeCases(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  // json.stringify pulls in _jsonStringifyNumber, which the shared rewrite does
+  // not map; stub it locally so the whole module loads. The runner only exercises
+  // the `is` predicates, so the stub body is immaterial.
+  if err := os.WriteFile(filepath.Join(runtimeDir, "json-stringify-number-stub.cjs"), []byte(patternLineTerminatorNumberStub), 0o644); err != nil {
+    t.Fatalf("write json stringify number stub: %v", err)
+  }
+  runtimeJS := strings.ReplaceAll(js, `require("typia/lib/internal/_jsonStringifyNumber")`, `require("./json-stringify-number-stub.cjs")`)
+  runtimeJS = ttscTypiaTestRewriteCommonJS(t, runtimeJS)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(patternLineTerminatorRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  if output, err := cmd.CombinedOutput(); err != nil {
+    t.Fatalf("line terminator pattern runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const patternLineTerminatorNumberStub = `module.exports._jsonStringifyNumber = (value) => String(value);
+`
+
+const patternLineTerminatorTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+// The template literal types embed the line terminators as TypeScript escapes
+// (backslash n, backslash r, backslash u2028, backslash u2029), which the
+// compiler folds into real line terminator characters in the literal type --
+// the exact trigger.
+const patternLineTerminatorSource = `import typia from "typia";
+
+export const isLF = typia.createIs<` + "`a\\n${string}b`" + `>();
+export const isCR = typia.createIs<` + "`a\\r${string}b`" + `>();
+export const isLS = typia.createIs<` + "`a\\u2028${string}b`" + `>();
+export const isPS = typia.createIs<` + "`a\\u2029${string}b`" + `>();
+export const isControl = typia.createIs<` + "`prefix${string}postfix`" + `>();
+
+type LFRecord = Record<` + "`a\\n${string}`" + `, number>;
+export const isRecord = typia.createIs<LFRecord>();
+export const stringifyRecord = typia.json.createStringify<LFRecord>();
+export const cloneRecord = typia.plain.createClone<LFRecord>();
+export const pruneRecord = typia.plain.createPrune<LFRecord>();
+export const camelRecord = typia.notations.createCamel<LFRecord>();
+`
+
+// Every value's only line terminator is the one the template's literal part
+// pins, so the trailing `(.*)` (dot excludes newlines) still matches the tail.
+// LF/CR go in as JS escapes and U+2028/U+2029 via String.fromCharCode so this
+// source carries no raw line terminator of its own.
+const patternLineTerminatorRuntimeRunner = `const mod = require("./main.cjs");
+
+const LS = String.fromCharCode(0x2028);
+const PS = String.fromCharCode(0x2029);
+const cases = [
+  ["isLF", "a\nZZb", "aZZb"],
+  ["isCR", "a\rZZb", "aZZb"],
+  ["isLS", "a" + LS + "ZZb", "aZZb"],
+  ["isPS", "a" + PS + "ZZb", "aZZb"],
+];
+for (const [name, good, bad] of cases) {
+  if (mod[name](good) !== true) {
+    throw new Error(name + " must accept a value carrying its line terminator: " + JSON.stringify(good));
+  }
+  if (mod[name](bad) !== false) {
+    throw new Error(name + " must reject a value lacking its line terminator: " + JSON.stringify(bad));
+  }
+}
+
+if (mod.isControl("prefix_mid_postfix") !== true) {
+  throw new Error("line-terminator-free template must still accept a conforming value");
+}
+if (mod.isControl("nope") !== false) {
+  throw new Error("line-terminator-free template must still reject a non-conforming value");
+}
+
+// A Record index signature only constrains keys its key pattern matches, so the
+// newline in the key regex is what decides which keys get the number check. A
+// matching key with a bad value must fail, while a near-miss key that lacks the
+// newline is not matched (and so is left unchecked) -- together they prove the
+// escaped line terminator is load-bearing in the emitted regex.
+const goodRecord = {};
+goodRecord["a\nkey"] = 1;
+if (mod.isRecord(goodRecord) !== true) {
+  throw new Error("Record: a matching key with a number value must pass");
+}
+const matchedBadValue = {};
+matchedBadValue["a\nkey"] = "not a number";
+if (mod.isRecord(matchedBadValue) !== false) {
+  throw new Error("Record: a newline-matching key with a non-number value must fail");
+}
+if (mod.isRecord({ "axkey": "not a number" }) !== true) {
+  throw new Error("Record: a key lacking the newline must not match the pattern, so it stays unchecked");
+}
+`