typia 13.1.1 → 13.2.0

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

@@ -0,0 +1,238 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestJsonStringifySpecialKeyTransform pins json.createStringify (and the
+// guarded isStringify / assertStringify / validateStringify variants) against a
+// static object key that contains a double quote, a backslash, a control
+// character, a `${` interpolation sequence, an empty string, or a backtick
+// (#2201).
+//
+// StringifyJoinder emits each static key by JSON-escaping it with
+// json.Marshal, then splicing the JSON bytes into a *template literal* through
+// TemplateFactory.Generate. JSON escaping and template-literal escaping
+// disagree, so at runtime `\"`->`"`, `\\`->`\`, a control char stays raw, a raw
+// backtick closes the template (a SyntaxError in the emitted module), and `${`
+// starts a live interpolation (a serialize-time ReferenceError / injection).
+// The result is invalid JSON, or a crash, for exactly these keys, while
+// ordinary keys, dynamic Record keys, and all string values stay correct.
+//
+//  1. Transform a fixture that exports json.createStringify (plus the guarded
+//     variants) for an object whose keys are `q"k`, `back\slash`, a TAB,
+//     `interp${bad}here`, the empty string, and a backtick.
+//  2. Execute the emitted serializer in Node with a faithful
+//     _jsonStringifyNumber stub.
+//  3. Require the serialized document to JSON.parse back to the original object
+//     for every key, and report the exact executed case count so a runner that
+//     silently skipped a key cannot pass as a false green.
+func TestJsonStringifySpecialKeyTransform(t *testing.T) {
+  project := jsonStringifySpecialKeyProject(t)
+  js := jsonStringifySpecialKeyTransform(t, project)
+  jsonStringifySpecialKeyRunRuntime(t, project, js)
+}
+
+func jsonStringifySpecialKeyProject(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, "json-stringify-special-key-")
+  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(jsonStringifySpecialKeyTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(jsonStringifySpecialKeySource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func jsonStringifySpecialKeyTransform(t *testing.T, project string) string {
+  t.Helper()
+  payload := `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+      "--plugins-json", payload,
+    })
+  })
+  if code != 0 {
+    t.Fatalf("json stringify special-key transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func jsonStringifySpecialKeyRunRuntime(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)
+  stubs := map[string]string{
+    "json-stringify-number-stub.cjs":  jsonStringifySpecialKeyNumberStub,
+    "json-stringify-string-stub.cjs":  jsonStringifySpecialKeyStringStub,
+    "throw-type-guard-error-stub.cjs": jsonStringifySpecialKeyThrowStub,
+  }
+  for name, content := range stubs {
+    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  runtimeJS := strings.ReplaceAll(js, `require("typia/lib/internal/_jsonStringifyNumber")`, `require("./json-stringify-number-stub.cjs")`)
+  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyString")`, `require("./json-stringify-string-stub.cjs")`)
+  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_throwTypeGuardError")`, `require("./throw-type-guard-error-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(jsonStringifySpecialKeyRunner), 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("json stringify special-key runtime failed: %v\n%s", err, output)
+  }
+  const expected = "RAN 24 CASES"
+  if !strings.Contains(string(output), expected) {
+    t.Fatalf("json stringify special-key runner did not report %q; got:\n%s", expected, output)
+  }
+}
+
+const jsonStringifySpecialKeyTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const jsonStringifySpecialKeySource = `import typia from "typia";
+
+interface Special {
+  "q\"k": number;
+  "back\\slash": number;
+  "\t": number;
+  "interp${bad}here": number;
+  "": number;
+  "` + "`" + `": number;
+}
+
+export const stringifySpecial = typia.json.createStringify<Special>();
+export const isStringifySpecial = typia.json.createIsStringify<Special>();
+export const assertStringifySpecial = typia.json.createAssertStringify<Special>();
+export const validateStringifySpecial = typia.json.createValidateStringify<Special>();
+`
+
+const jsonStringifySpecialKeyNumberStub = `module.exports._jsonStringifyNumber = (value) => (Number.isFinite(value) ? String(value) : "null");
+`
+
+const jsonStringifySpecialKeyStringStub = `module.exports._jsonStringifyString = (value) => JSON.stringify(value);
+`
+
+const jsonStringifySpecialKeyThrowStub = `module.exports._throwTypeGuardError = (props) => {
+  const error = new Error(props.expected);
+  Object.assign(error, props);
+  throw error;
+};
+`
+
+const jsonStringifySpecialKeyRunner = `const mod = require("./main.cjs");
+
+const TAB = String.fromCharCode(9);
+const BQ = String.fromCharCode(96);
+
+const makeInput = () => {
+  const input = {};
+  input['q"k'] = 1;
+  input['back\\slash'] = 2;
+  input[TAB] = 3;
+  input['interp${bad}here'] = 4;
+  input[''] = 5;
+  input[BQ] = 6;
+  return input;
+};
+
+const entries = [
+  ['q"k', 1],
+  ['back\\slash', 2],
+  [TAB, 3],
+  ['interp${bad}here', 4],
+  ['', 5],
+  [BQ, 6],
+];
+
+let ran = 0;
+
+const roundTrip = (label, text) => {
+  const parsed = JSON.parse(text);
+  for (const [key, expected] of entries) {
+    ran += 1;
+    if (parsed[key] !== expected) {
+      throw new Error(
+        label + ": key " + JSON.stringify(key) + " round-trip failed; got " +
+          JSON.stringify(parsed[key]) + " in " + text,
+      );
+    }
+  }
+  if (Object.keys(parsed).length !== entries.length) {
+    throw new Error(label + ": unexpected key count in " + text);
+  }
+};
+
+// json.createStringify: the raw serializer must emit valid JSON for every key.
+roundTrip("createStringify", mod.stringifySpecial(makeInput()));
+
+// json.createIsStringify: valid input serializes; the document must round-trip.
+const isText = mod.isStringifySpecial(makeInput());
+if (isText === null) {
+  throw new Error("isStringify rejected a valid special-key object");
+}
+roundTrip("isStringify", isText);
+
+// json.createAssertStringify: valid input passes the guard, then serializes.
+roundTrip("assertStringify", mod.assertStringifySpecial(makeInput()));
+
+// json.createValidateStringify: success carries the serialized document.
+const validated = mod.validateStringifySpecial(makeInput());
+if (validated.success !== true) {
+  throw new Error("validateStringify rejected a valid special-key object: " + JSON.stringify(validated));
+}
+roundTrip("validateStringify", validated.data);
+
+console.log("RAN " + ran + " CASES");
+`

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

@@ -0,0 +1,277 @@
+package main
+
+import (
+  "fmt"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLibReplacementNativeIdentityTransform keeps a `libReplacement` project's
+// natives native even though their declaration file lives in node_modules
+// (#2200).
+//
+// Runtime-native identity requires a runtime authority to declare the global, so
+// which files count as a TypeScript default library became load-bearing. Under
+// `libReplacement` the compiler resolves `lib.es2015.collection.d.ts` to
+// `@typescript/lib-es2015/collection`, an ordinary package file whose name does
+// not even begin with `lib.` — so a file-name rule answers "not a default
+// library" and would demote Map, Set, WeakMap, and WeakSet to structural checks
+// that accept any object. Only the program's own classification is right here,
+// and this fixture is what proves the transform consults it.
+//
+//  1. Publish `@typescript/lib-es2015/collection.d.ts` carrying the real
+//     Map/Set/WeakMap/WeakSet declarations plus a probe interface that exists
+//     nowhere else, and enable `libReplacement`.
+//  2. Transform validators for the four replaced collection natives, for Date
+//     and Uint8Array as bundled-library controls, and for the probe.
+//  3. Require the probe to transform at all, which fails unless the replacement
+//     file — not the bundled lib — is what the program loaded.
+//  4. Require every native to keep its `instanceof` check and execute all of
+//     them in Node against real instances and plain objects.
+func TestLibReplacementNativeIdentityTransform(t *testing.T) {
+  project := libReplacementNativeIdentityProject(t)
+  js, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/input.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("lib replacement transform failed: code=%d stderr=\n%s", code, errText)
+  }
+
+  failures := []string{}
+  if !strings.Contains(js, "libReplacementMarker") {
+    failures = append(failures, "emit lost the replacement-only probe member; the project did not load the replaced lib file")
+  }
+  for _, kept := range []string{
+    "instanceof Map",
+    "instanceof Set",
+    "instanceof WeakMap",
+    "instanceof WeakSet",
+    "instanceof Date",
+    "instanceof Uint8Array",
+  } {
+    if !strings.Contains(js, kept) {
+      failures = append(failures, fmt.Sprintf("replaced or bundled default library native lost %q", kept))
+    }
+  }
+
+  output, runtimeErr := libReplacementNativeIdentityRun(t, project, js)
+  if runtimeErr != nil {
+    failures = append(failures, fmt.Sprintf("runtime matrix failed: %v\n%s", runtimeErr, output))
+  }
+  if expected := "RAN 13 REPLACEMENT CASES"; !strings.Contains(output, expected) {
+    failures = append(failures, fmt.Sprintf("replacement runner did not report %q; got:\n%s", expected, output))
+  }
+  if len(failures) != 0 {
+    t.Fatalf("lib replacement native identity mismatches:\n%s\n\nemit:\n%s", strings.Join(failures, "\n"), js)
+  }
+}
+
+func libReplacementNativeIdentityProject(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, "lib-replacement-native-identity-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  for name, content := range map[string]string{
+    "tsconfig.json": libReplacementNativeIdentityTSConfig,
+    "node_modules/@typescript/lib-es2015/package.json":   libReplacementNativeIdentityPackageJSON,
+    "node_modules/@typescript/lib-es2015/collection.d.ts": libReplacementNativeIdentityCollectionLib,
+    "src/input.ts": libReplacementNativeIdentitySource,
+  } {
+    path := filepath.Join(dir, filepath.FromSlash(name))
+    if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+      t.Fatalf("mkdir fixture path %s: %v", filepath.Dir(path), err)
+    }
+    if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+      t.Fatalf("write fixture file %s: %v", path, err)
+    }
+  }
+  return dir
+}
+
+func libReplacementNativeIdentityRun(t *testing.T, project string, js string) (string, error) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+    return "", nil
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  for name, content := range map[string]string{
+    "input.cjs": ttscTypiaTestRewriteCommonJS(t, js),
+    "run.cjs":   libReplacementNativeIdentityRuntimeRunner,
+  } {
+    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
+      t.Fatalf("write runtime file %s: %v", name, err)
+    }
+  }
+  cmd := exec.Command(node, filepath.Join(runtimeDir, "run.cjs"))
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  return string(output), err
+}
+
+const libReplacementNativeIdentityTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "lib": ["ES2022"],
+    "types": [],
+    "libReplacement": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const libReplacementNativeIdentityPackageJSON = `{
+  "name": "@typescript/lib-es2015",
+  "version": "1.0.0"
+}
+`
+
+// libReplacementNativeIdentityCollectionLib is the replacement TypeScript loads
+// instead of its bundled `lib.es2015.collection.d.ts`. The collection
+// declarations are transcribed from that file so the rest of the standard
+// library still typechecks against them; `LibReplacementProbe` is the one
+// addition, and it is what proves the program loaded this file.
+const libReplacementNativeIdentityCollectionLib = `interface LibReplacementProbe {
+    libReplacementMarker: string;
+}
+
+interface Map<K, V> {
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    readonly size: number;
+}
+
+interface MapConstructor {
+    new (): Map<any, any>;
+    new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
+    readonly prototype: Map<any, any>;
+}
+declare var Map: MapConstructor;
+
+interface ReadonlyMap<K, V> {
+    forEach(callbackfn: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    readonly size: number;
+}
+
+interface WeakMap<K extends WeakKey, V> {
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+}
+
+interface WeakMapConstructor {
+    new <K extends WeakKey = WeakKey, V = any>(entries?: readonly (readonly [K, V])[] | null): WeakMap<K, V>;
+    readonly prototype: WeakMap<WeakKey, any>;
+}
+declare var WeakMap: WeakMapConstructor;
+
+interface Set<T> {
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    readonly size: number;
+}
+
+interface SetConstructor {
+    new <T = any>(values?: readonly T[] | null): Set<T>;
+    readonly prototype: Set<any>;
+}
+declare var Set: SetConstructor;
+
+interface ReadonlySet<T> {
+    forEach(callbackfn: (value: T, value2: T, set: ReadonlySet<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    readonly size: number;
+}
+
+interface WeakSet<T extends WeakKey> {
+    add(value: T): this;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+}
+
+interface WeakSetConstructor {
+    new <T extends WeakKey = WeakKey>(values?: readonly T[] | null): WeakSet<T>;
+    readonly prototype: WeakSet<WeakKey>;
+}
+declare var WeakSet: WeakSetConstructor;
+`
+
+const libReplacementNativeIdentitySource = `import typia from "typia";
+
+export const createdIsProbe = typia.createIs<LibReplacementProbe>();
+export const createdIsMap = typia.createIs<Map<string, number>>();
+export const createdIsSet = typia.createIs<Set<string>>();
+export const createdIsWeakMap = typia.createIs<WeakMap<object, string>>();
+export const createdIsWeakSet = typia.createIs<WeakSet<object>>();
+export const createdIsDate = typia.createIs<Date>();
+export const createdIsBytes = typia.createIs<Uint8Array>();
+`
+
+const libReplacementNativeIdentityRuntimeRunner = `const validators = require("./input.cjs");
+
+let ran = 0;
+const failures = [];
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    failures.push(name + ": expected " + expected + " but got " + actual);
+  }
+};
+
+eq("probe structural", validators.createdIsProbe({ libReplacementMarker: "x" }), true);
+eq("Map real", validators.createdIsMap(new Map([["x", 1]])), true);
+eq("Map plain", validators.createdIsMap({}), false);
+eq("Set real", validators.createdIsSet(new Set(["x"])), true);
+eq("Set plain", validators.createdIsSet({}), false);
+eq("WeakMap real", validators.createdIsWeakMap(new WeakMap()), true);
+eq("WeakMap plain", validators.createdIsWeakMap({}), false);
+eq("WeakSet real", validators.createdIsWeakSet(new WeakSet()), true);
+eq("WeakSet plain", validators.createdIsWeakSet({}), false);
+eq("Date real", validators.createdIsDate(new Date()), true);
+eq("Date plain", validators.createdIsDate({}), false);
+eq("Uint8Array real", validators.createdIsBytes(new Uint8Array(1)), true);
+eq("Uint8Array plain", validators.createdIsBytes({}), false);
+
+console.log("RAN " + ran + " REPLACEMENT CASES");
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`

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

@@ -74,6 +74,7 @@ func jsVersion(this js.Value, args []js.Value) any {
 //     file?:    string,   // absolute path of the .ts file to rewrite. Omit
 //                         // for project-wide JSON output.
 //     output?:  "ts"|"js",
+//     "plugins-json"?: string, // ttsc's resolved plugin manifest; see buildArgs
 //   }
 //
 // JS output: Promise<{ code: number, stdout: string, stderr: string }>.
@@ -154,9 +155,11 @@ func transformArgs(opts js.Value) []string {
   } else {
     out = append(out, "--output=ts")
   }
-  return out
+  return append(out, pluginsJSONArgs(opts)...)
 }
 
+// buildArgs renders the JS options object into `runBuild`'s argv. Input mirrors
+// jsTransform but carries `outDir`/`emit`/`noEmit` instead of `file`/`output`.
 func buildArgs(opts js.Value) []string {
   out := []string{}
   if v := stringProp(opts, "cwd"); v != "" {
@@ -176,7 +179,23 @@ func buildArgs(opts js.Value) []string {
   if boolProp(opts, "noEmit") {
     out = append(out, "--noEmit")
   }
-  return out
+  return append(out, pluginsJSONArgs(opts)...)
+}
+
+// pluginsJSONArgs forwards ttsc's resolved plugin manifest, when the caller
+// supplied one.
+//
+// typia's options come from the entry its host resolved and handed it, never
+// from re-reading tsconfig.json (samchon/typia#1887). A JS host driving this
+// wasm is that host: it owns the virtual filesystem the tsconfig lives in, so it
+// is the one that knows the resolved entry. Without this pass-through the wasm
+// could only ever run typia at its defaults, because there would be no channel
+// left to state anything else.
+func pluginsJSONArgs(opts js.Value) []string {
+  if v := stringProp(opts, "plugins-json"); v != "" {
+    return []string{"--plugins-json=" + v}
+  }
+  return nil
 }
 
 func runWithCapturedIO(task func() int) any {