typia 13.1.0 → 13.1.19

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

@@ -0,0 +1,205 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestIsObjectFunctionMemberTransform pins the runtime behavior of typia.is /
+// assert / validate for the global `Object` interface and for `Function`-typed
+// members (#2178).
+//
+// The global TS `Object` interface carries `constructor: Function`. The global
+// `Function` interface is declared as an `InterfaceDeclaration`, so before the
+// fix typia failed to recognize it as a function type and expanded it
+// structurally to `{ prototype, length, arguments, caller, name }`. That made
+// the `constructor` member emit `"object" === typeof input.constructor`, which
+// is never satisfied by a real constructor (`typeof === "function"`), so
+// `is<Object>(x)` was false for every input. The same defect struck any explicit
+// `Function`-typed member and any interface that `extends Object`.
+//
+// After the fix the lib `Function` interface is classified as a function and
+// routes through the same lenient member path typia already uses for
+// `() => void` members, so `is<Object>` collapses to a non-null-object gate.
+// The lowercase `object` keyword and the `{}` type must stay byte-identical
+// (they keep their `Array.isArray` guard), and the null / undefined / primitive
+// boundaries must stay false.
+//
+//  1. Transform one fixture that exports is / assert / validate for `Object`, an
+//     explicit `{ fn: Function }`, a `Moment extends Object` interface, plus the
+//     lowercase `object` and `{}` regression guards.
+//  2. Execute the emitted validators in Node against the boundary matrix.
+//  3. Require the runner to report the exact executed case count so a runner that
+//     silently skipped cases cannot pass as a false green.
+func TestIsObjectFunctionMemberTransform(t *testing.T) {
+  project := isObjectFunctionMemberProject(t)
+  js := isObjectFunctionMemberTransform(t, project)
+  isObjectFunctionMemberRunRuntimeCases(t, project, js)
+}
+
+func isObjectFunctionMemberProject(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, "is-object-function-member-")
+  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(finiteOptionNumberLeafTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(isObjectFunctionMemberSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func isObjectFunctionMemberTransform(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("is<Object> transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func isObjectFunctionMemberRunRuntimeCases(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(isObjectFunctionMemberRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = project
+  output, err := cmd.CombinedOutput()
+  if err != nil {
+    t.Fatalf("is<Object> runtime cases failed: %v\n%s", err, output)
+  }
+  const expected = "RAN 27 CASES"
+  if !strings.Contains(string(output), expected) {
+    t.Fatalf("is<Object> runner did not report %q; got:\n%s", expected, output)
+  }
+}
+
+const isObjectFunctionMemberSource = `import typia from "typia";
+
+interface Moment extends Object {
+  valueOf(): number;
+}
+
+export const isObject = typia.createIs<Object>();
+export const assertObject = typia.createAssert<Object>();
+export const validateObject = typia.createValidate<Object>();
+
+export const isFuncMember = typia.createIs<{ fn: Function }>();
+export const isMoment = typia.createIs<Moment>();
+
+export const isLowerObject = typia.createIs<object>();
+export const isEmptyObject = typia.createIs<{}>();
+
+// random must produce a sample that its own is accepts (round trip). Object and
+// a Function-only member need no numeric generator stub, so they stay hermetic.
+export const randomObject = typia.createRandom<Object>();
+export const randomFuncOnly = typia.createRandom<{ fn: Function }>();
+
+export const captureThrow = (task: () => void): boolean => {
+  try {
+    task();
+    return false;
+  } catch {
+    return true;
+  }
+};
+`
+
+const isObjectFunctionMemberRuntimeRunner = `const mod = require("./main.cjs");
+
+let ran = 0;
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    throw new Error(name + ": expected " + expected + " but got " + actual);
+  }
+};
+
+// is<Object>: every non-null object is accepted, including arrays and class
+// instances; null / undefined / primitives stay rejected (#2178 core cases).
+eq("is<Object>({})", mod.isObject({}), true);
+eq("is<Object>({a:1})", mod.isObject({ a: 1 }), true);
+eq("is<Object>(new Object())", mod.isObject(new Object()), true);
+eq("is<Object>(new Date())", mod.isObject(new Date()), true);
+eq("is<Object>([])", mod.isObject([]), true);
+eq("is<Object>(null)", mod.isObject(null), false);
+eq("is<Object>(undefined)", mod.isObject(undefined), false);
+eq("is<Object>(5)", mod.isObject(5), false);
+eq("is<Object>('x')", mod.isObject("x"), false);
+
+// validate and assert share the checker object path, so they must agree with is.
+eq("validate<Object>({})", mod.validateObject({}).success, true);
+eq("validate<Object>({a:1})", mod.validateObject({ a: 1 }).success, true);
+eq("validate<Object>(null)", mod.validateObject(null).success, false);
+eq("assert<Object>({}) no throw", mod.captureThrow(() => mod.assertObject({})), false);
+eq("assert<Object>(null) throws", mod.captureThrow(() => mod.assertObject(null)), true);
+
+// Explicit Function-typed member: the same lenient function path as () => void.
+eq("is<{fn:Function}>({fn(){}})", mod.isFuncMember({ fn() {} }), true);
+eq("is<{fn:Function}>({fn:()=>{}})", mod.isFuncMember({ fn: () => {} }), true);
+eq("is<{fn:Function}>(null)", mod.isFuncMember(null), false);
+
+// interface Moment extends Object: the inherited constructor member no longer
+// breaks a real instance.
+eq("is<Moment>(real)", mod.isMoment({ valueOf: () => 1 }), true);
+eq("is<Moment>(null)", mod.isMoment(null), false);
+
+// lowercase object keeps its Array.isArray guard (byte-identical, unchanged).
+eq("is<object>({})", mod.isLowerObject({}), true);
+eq("is<object>([])", mod.isLowerObject([]), false);
+eq("is<object>(null)", mod.isLowerObject(null), false);
+
+// {} empty object type keeps its Array.isArray guard (byte-identical, unchanged).
+eq("is<{}>({})", mod.isEmptyObject({}), true);
+eq("is<{}>([])", mod.isEmptyObject([]), false);
+eq("is<{}>(null)", mod.isEmptyObject(null), false);
+
+// random <-> is round trip: the generated Object / Function-member sample must
+// pass its own is checker.
+eq("is<Object>(random<Object>())", mod.isObject(mod.randomObject()), true);
+eq("is<{fn:Function}>(random)", mod.isFuncMember(mod.randomFuncOnly()), true);
+
+console.log("RAN " + ran + " CASES");
+`

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

@@ -0,0 +1,151 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestJsonApplicationAliasFunctionValidation verifies that a function property
+// written through a `type` alias reaches the same #2195 guards as an inline one.
+//
+// `json.application` keeps the alias on the property value it validates but
+// unaliases the one it emits, so before #2216 the two disagreed: `Validate` read
+// `p.Value.Functions` (empty for an aliased member) and skipped every per-function
+// check, while `WriteApplication` unaliased and silently dropped the malformed
+// function. The mirror case rejected a valid aliased application with a spurious
+// "must have at least a function type." This pins both directions.
+//
+//  1. Reject an aliased union / optional / nullable function with its exact
+//     #2195 diagnostic, matching the inline sibling fixtures.
+//  2. Accept an aliased required single function (direct and through a deep
+//     alias chain), emitting it and reporting no "at least a function" error.
+func TestJsonApplicationAliasFunctionValidation(t *testing.T) {
+  for _, tt := range []struct {
+    name     string
+    source   string
+    fragment string
+  }{
+    {
+      name: "alias-union",
+      source: `import typia from "typia";
+type BadUnion = (() => number) | ((value: number) => string);
+typia.json.application<{ good(): number; bad: BadUnion; }>();
+`,
+      fragment: "JSON application's function type does not allow union type.",
+    },
+    {
+      name: "alias-optional",
+      source: `import typia from "typia";
+type BadFn = () => number;
+typia.json.application<{ good(): number; bad?: BadFn; }>();
+`,
+      fragment: "JSON application's function type must be required.",
+    },
+    {
+      name: "alias-nullable",
+      source: `import typia from "typia";
+type BadFn = () => number;
+typia.json.application<{ good(): number; bad: BadFn | null; }>();
+`,
+      fragment: "JSON application's function type must not be nullable.",
+    },
+  } {
+    jsonApplicationAliasExpectDiagnostic(t, tt.name, tt.source, tt.fragment)
+  }
+
+  for _, tt := range []struct {
+    name     string
+    source   string
+    function string
+  }{
+    {
+      name: "alias-required-single",
+      source: `import typia from "typia";
+type GoodFn = () => number;
+typia.json.application<{ only: GoodFn; }>();
+`,
+      function: "only",
+    },
+    {
+      name: "alias-deep-chain",
+      source: `import typia from "typia";
+type A = B;
+type B = () => number;
+typia.json.application<{ deep: A; }>();
+`,
+      function: "deep",
+    },
+  } {
+    jsonApplicationAliasExpectInclusion(t, tt.name, tt.source, tt.function)
+  }
+}
+
+func jsonApplicationAliasExpectDiagnostic(t *testing.T, name string, source string, fragment string) {
+  t.Helper()
+  project := jsonApplicationAliasProject(t, name, source)
+  _, errText, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", filepath.Join(project, "dist"),
+    })
+  })
+  if code != 3 {
+    t.Fatalf("%s aliased application build should fail with code 3, got %d\nstderr=%s", name, code, errText)
+  }
+  for _, want := range []string{"error TS(typia.json.application):", fragment} {
+    if !strings.Contains(errText, want) {
+      t.Fatalf("%s aliased application diagnostic missing %q:\n%s", name, want, errText)
+    }
+  }
+}
+
+func jsonApplicationAliasExpectInclusion(t *testing.T, name string, source string, function string) {
+  t.Helper()
+  project := jsonApplicationAliasProject(t, name, source)
+  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("%s valid aliased application should transform, got code %d\nstderr=%s", name, code, errText)
+  }
+  if !strings.Contains(out, `name: "`+function+`"`) {
+    t.Fatalf("%s valid aliased application dropped its function %q:\n%s", name, function, out)
+  }
+  if strings.Contains(out, "at least a function") {
+    t.Fatalf("%s valid aliased application reported a spurious empty-application error:\n%s", name, out)
+  }
+}
+
+func jsonApplicationAliasProject(t *testing.T, name 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, "json-application-alias-"+name+"-")
+  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(randomRecursiveMinItemsTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}

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

@@ -0,0 +1,198 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestJsonIsStringifyFiniteNumberTransform pins json.isStringify against a bare
+// number leaf so a non-finite value cannot leak into the serialized text (#2196).
+//
+// json.isStringify forces Options.Finite on its inner `__is` guard precisely to
+// keep NaN and Infinity out of JSON. Because `is` dropped `finite`, that guard
+// accepted NaN, so `__is(input) ? __stringify(input) : null` serialized the input
+// instead of returning the top-level null it owes an invalid value. Both option
+// rows reproduce a distinct failure the fix must close:
+//
+//   - default options: the validated stringify folds the number through
+//     _jsonStringifyNumber, so NaN silently became `{"value":null}` -- an accepted
+//     invalid input rather than a rejected one.
+//   - finite:true: the validated stringify emits raw `String(input)` for the
+//     number, so NaN became the literal `{"value":NaN}` token -- invalid JSON that
+//     JSON.parse throws on. This is the corruption hole the guard closes.
+//
+//  1. Transform a `json.isStringify<{ value: number }>` fixture per option row.
+//  2. Execute the emitted serializer in Node.
+//  3. Require a finite value to serialize and NaN/Infinity/-Infinity to yield null.
+func TestJsonIsStringifyFiniteNumberTransform(t *testing.T) {
+  for _, tc := range jsonIsStringifyFiniteNumberCases() {
+    t.Run(tc.name, func(t *testing.T) {
+      project := jsonIsStringifyFiniteNumberProject(t)
+      js := jsonIsStringifyFiniteNumberTransform(t, project, tc.payload)
+      jsonIsStringifyFiniteNumberRunRuntime(t, project, js)
+    })
+  }
+}
+
+type jsonIsStringifyFiniteNumberCase struct {
+  name    string
+  payload string
+}
+
+func jsonIsStringifyFiniteNumberCases() []jsonIsStringifyFiniteNumberCase {
+  return []jsonIsStringifyFiniteNumberCase{
+    {
+      name:    "default options",
+      payload: `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`,
+    },
+    {
+      name:    "finite option on",
+      payload: `[{"config":{"transform":"typia/lib/transform","finite":true},"name":"typia","stage":"transform"}]`,
+    },
+  }
+}
+
+func jsonIsStringifyFiniteNumberProject(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-is-stringify-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(jsonIsStringifyFiniteNumberTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(jsonIsStringifyFiniteNumberSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func jsonIsStringifyFiniteNumberTransform(t *testing.T, project string, payload string) string {
+  t.Helper()
+  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 isStringify finite transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func jsonIsStringifyFiniteNumberRunRuntime(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":  jsonIsStringifyScopedCheckerNumberStub,
+    "json-stringify-string-stub.cjs":  jsonIsStringifyScopedCheckerStringStub,
+    "throw-type-guard-error-stub.cjs": jsonIsStringifyScopedCheckerThrowStub,
+  }
+  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(jsonIsStringifyFiniteNumberRunner), 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 isStringify finite runtime failed: %v\n%s", err, output)
+  }
+  const expected = "RAN 4 CASES"
+  if !strings.Contains(string(output), expected) {
+    t.Fatalf("json isStringify finite runner did not report %q; got:\n%s", expected, output)
+  }
+}
+
+const jsonIsStringifyFiniteNumberTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const jsonIsStringifyFiniteNumberSource = `import typia from "typia";
+
+interface Box {
+  value: number;
+}
+
+export const stringify = (input: unknown): string | null =>
+  typia.json.isStringify<Box>(input);
+`
+
+const jsonIsStringifyFiniteNumberRunner = `const mod = require("./main.cjs");
+
+const finite = mod.stringify({ value: 1 });
+if (finite === null) {
+  throw new Error("json.isStringify rejected a finite number");
+}
+const parsed = JSON.parse(finite);
+if (parsed.value !== 1) {
+  throw new Error("json.isStringify serialized the wrong value: " + finite);
+}
+
+let ran = 1;
+for (const [name, value] of [
+  ["NaN", Number.NaN],
+  ["Infinity", Number.POSITIVE_INFINITY],
+  ["-Infinity", Number.NEGATIVE_INFINITY],
+]) {
+  const out = mod.stringify({ value });
+  ran += 1;
+  if (out !== null) {
+    throw new Error(
+      name + " leaked into json.isStringify output instead of null: " + JSON.stringify(out),
+    );
+  }
+}
+
+console.log("RAN " + ran + " CASES");
+`