typia 14.0.6 → 15.0.1

package/native/core/programmers/http/HttpQueryProgrammer.go

@@ -30,6 +30,14 @@ type HttpQueryProgrammer_DecomposeProps struct {
   AllowOptional bool
   Type          *shimchecker.Type
   Name          *string
+
+  // Missing makes the decoder throw `Error("missing <key>")` for an absent
+  // required non-array property. Only `http.query`, which validates nothing
+  // else, asks for it. The `is`, `assert`, and `validate` variants decode
+  // through this same function and must report the absence through their own
+  // contract instead (`null`, an `IValidation` failure, `TypeGuardError`), so
+  // they leave it off (samchon/typia#2444).
+  Missing bool
 }
 
 var httpQueryProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
@@ -78,9 +86,11 @@ func (httpQueryProgrammerNamespace) Decompose(props HttpQueryProgrammer_Decompos
   statements := httpQueryProgrammer_decode_object(struct {
     Context nativecontext.ITypiaContext
     Object  *schemametadata.MetadataObjectType
+    Missing bool
   }{
     Context: props.Context,
     Object:  object,
+    Missing: props.Missing,
   })
   return nativeinternal.FeatureProgrammer_IDecomposed{
     Functions:  map[string]*shimast.Node{},
@@ -124,6 +134,7 @@ func (httpQueryProgrammerNamespace) Write(props HttpQueryProgrammer_IProps) *shi
     AllowOptional: props.AllowOptional,
     Type:          props.Type,
     Name:          props.Name,
+    Missing:       true,
   })
   return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
     Modulo:  props.Modulo,
@@ -203,6 +214,7 @@ func (httpQueryProgrammerNamespace) Validate(props struct {
 func httpQueryProgrammer_decode_object(props struct {
   Context nativecontext.ITypiaContext
   Object  *schemametadata.MetadataObjectType
+  Missing bool
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
   input := f.NewIdentifier("input")
@@ -212,9 +224,11 @@ func httpQueryProgrammer_decode_object(props struct {
     properties = append(properties, httpQueryProgrammer_decode_regular_property(struct {
       Context  nativecontext.ITypiaContext
       Property *schemametadata.MetadataProperty
+      Missing  bool
     }{
       Context:  props.Context,
       Property: p,
+      Missing:  props.Missing,
     }))
   }
   return []*shimast.Node{
@@ -253,6 +267,7 @@ func httpQueryProgrammer_decode_object(props struct {
 func httpQueryProgrammer_decode_regular_property(props struct {
   Context  nativecontext.ITypiaContext
   Property *schemametadata.MetadataProperty
+  Missing  bool
 }) *shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
   key := httpProgrammer_property_key(props.Property)
@@ -277,9 +292,9 @@ func httpQueryProgrammer_decode_regular_property(props struct {
       }),
       shimast.NodeFlagsNone,
     )
-    if value.IsRequired() {
-      input = httpQueryProgrammer_assert_required_array(key, input, props.Context.Emit)
-    }
+    // An absent key reads as an empty list. A query string has no other
+    // spelling for `[]`, so a required array decodes it as `[]` rather than as
+    // a missing property, and a nullable one as `null` (samchon/typia#2444).
     input = f.NewCallExpression(
       nativefactories.IdentifierFactory.Access(
         props.Context.Emit,
@@ -301,11 +316,13 @@ func httpQueryProgrammer_decode_regular_property(props struct {
           httpQueryProgrammer_decode_value(struct {
             Context  nativecontext.ITypiaContext
             Type     string
+            Nullable bool
             Coalesce bool
             Input    *shimast.Node
           }{
             Context:  props.Context,
             Type:     typ,
+            Nullable: httpProgrammer_decode_nullable(value),
             Coalesce: false,
             Input:    f.NewIdentifier("elem"),
           }),
@@ -323,18 +340,20 @@ func httpQueryProgrammer_decode_regular_property(props struct {
       Input:    input,
     })
   } else {
-    if value.IsRequired() {
+    if value.IsRequired() && props.Missing {
       input = httpQueryProgrammer_assert_required_value(key, input, props.Context.Emit)
     }
     input = httpQueryProgrammer_decode_value(struct {
       Context  nativecontext.ITypiaContext
       Type     string
+      Nullable bool
       Coalesce bool
       Input    *shimast.Node
     }{
       Context:  props.Context,
       Type:     typ,
-      Coalesce: value.Nullable == false && value.IsRequired() == false,
+      Nullable: httpProgrammer_decode_nullable(value),
+      Coalesce: value.Nullable == false && value.Any == false && value.IsRequired() == false,
       Input:    input,
     })
   }
@@ -350,6 +369,7 @@ func httpQueryProgrammer_decode_regular_property(props struct {
 func httpQueryProgrammer_decode_value(props struct {
   Context  nativecontext.ITypiaContext
   Type     string
+  Nullable bool
   Coalesce bool
   Input    *shimast.Node
 }) *shimast.Node {
@@ -358,7 +378,7 @@ func httpQueryProgrammer_decode_value(props struct {
     httpParameterProgrammer_internal(props.Context, "httpQueryRead"+httpParameterProgrammer_capitalize(props.Type)),
     nil,
     nil,
-    f.NewNodeList([]*shimast.Node{props.Input}),
+    f.NewNodeList(httpProgrammer_read_arguments(props.Type, props.Nullable, props.Input, props.Context.Emit)),
     shimast.NodeFlagsNone,
   )
   if props.Coalesce == false {
@@ -410,43 +430,6 @@ func httpQueryProgrammer_assert_required_value(key string, input *shimast.Node,
   )
 }
 
-func httpQueryProgrammer_assert_required_array(key string, input *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, emit...)
-  value := f.NewIdentifier("value")
-  return f.NewCallExpression(
-    f.NewArrowFunction(
-      nil,
-      nil,
-      f.NewNodeList(nil),
-      nil,
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      f.NewBlock(f.NewNodeList([]*shimast.Node{
-        nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-          Name:  "value",
-          Value: input,
-        }, emit...),
-        f.NewIfStatement(
-          f.NewBinaryExpression(
-            nil,
-            nativefactories.ExpressionFactory.Number(0, emit...),
-            nil,
-            f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-            nativefactories.IdentifierFactory.Access(nil, value, "length"),
-          ),
-          f.NewThrowStatement(httpQueryProgrammer_missing_error(key, emit...)),
-          nil,
-        ),
-        f.NewReturnStatement(value),
-      }), true),
-    ),
-    nil,
-    nil,
-    nil,
-    shimast.NodeFlagsNone,
-  )
-}
-
 func httpQueryProgrammer_missing_error(key string, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, emit...)
   return f.NewNewExpression(

package/native/core/programmers/iterate/json_schema_jsDocTags.go

@@ -1,10 +1,10 @@
 package iterate
 
 import (
-  "strconv"
   "strings"
 
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 func json_schema_jsDocTags(schema JsonSchema, jsDocTags []nativemetadata.IJsDocTagInfo) JsonSchema {
@@ -31,6 +31,13 @@ func json_schema_jsDocTags_value(tag nativemetadata.IJsDocTagInfo) (string, bool
   return "", false
 }
 
+// json_schema_jsDocTags_cast reads an `@x-*` tag's text as a JSON value.
+//
+// Numbers use JavaScript's `Number()` grammar, the grammar of the v12 cast this
+// ports (samchon/typia#2442), so `0x10` is 16 while Go-only spellings such as
+// `0x1p4`, `1_000`, and `inf` stay text. Only finite numbers become numbers: the
+// schema is JSON, which has no NaN or infinity, so `NaN`, `Infinity`, and an
+// overflowing `1e400` keep their text instead of degrading to `null`.
 func json_schema_jsDocTags_cast(value string) any {
   if value == "true" {
     return true
@@ -38,8 +45,8 @@ func json_schema_jsDocTags_cast(value string) any {
   if value == "false" {
     return false
   }
-  if num, err := strconv.ParseFloat(value, 64); err == nil {
-    return num
+  if reading := nativeutils.NumberUtil.Read(value); reading.Numeric && reading.Finite {
+    return reading.Value
   }
   if value == "null" {
     return nil

package/native/core/programmers/iterate/json_schema_jsdoc_tags_cast_reads_javascript_numbers_test.go

@@ -0,0 +1,64 @@
+package iterate
+
+import (
+  "encoding/json"
+  "math"
+  "reflect"
+  "testing"
+)
+
+// TestJsonSchemaJsDocTagsCastReadsJavaScriptNumbers verifies the `@x-*`
+// extension cast.
+//
+// The Go port swapped the v12 cast's JavaScript `Number()` grammar for Go's
+// float syntax (samchon/typia#2442). `NaN` and every `Inf` spelling then became
+// floats that `encoding/json` refuses and JavaScript prints as `null`, while
+// `0x10` stopped being a number and `0x1p4` / `1_000` started being one. The
+// expectations restore v12's numbers where they are finite and keep the text
+// where JSON has no number: a non-finite spelling stays a string instead of
+// degrading to `null`, and empty text stays `""` instead of v12's `0`.
+//
+//  1. Cast every row of the issue's table.
+//  2. Assert no result is NaN or an infinity, and every result marshals.
+func TestJsonSchemaJsDocTagsCastReadsJavaScriptNumbers(t *testing.T) {
+  for _, item := range []struct {
+    text     string
+    expected any
+  }{
+    {"NaN", "NaN"},
+    {"nan", "nan"},
+    {"Infinity", "Infinity"},
+    {"-Infinity", "-Infinity"},
+    {"infinity", "infinity"},
+    {"inf", "inf"},
+    {"Inf", "Inf"},
+    {"1e400", "1e400"},
+    {"0x10", float64(16)},
+    {"0b101", float64(5)},
+    {"0o7", float64(7)},
+    {"0x1p4", "0x1p4"},
+    {"1_000", "1_000"},
+    {"", ""},
+    {"-0", float64(0)},
+    {"+5", float64(5)},
+    {".5", 0.5},
+    {"1e3", float64(1000)},
+    {"true", true},
+    {"false", false},
+    {"null", nil},
+    {"text", "text"},
+  } {
+    actual := json_schema_jsDocTags_cast(item.text)
+    if reflect.DeepEqual(actual, item.expected) == false {
+      t.Fatalf("cast(%q) = %#v, expected %#v", item.text, actual, item.expected)
+    }
+    if number, ok := actual.(float64); ok {
+      if math.IsNaN(number) || math.IsInf(number, 0) || math.Signbit(number) && number == 0 {
+        t.Fatalf("cast(%q) = %v is not a JSON number", item.text, number)
+      }
+    }
+    if _, err := json.Marshal(actual); err != nil {
+      t.Fatalf("cast(%q) does not marshal: %v", item.text, err)
+    }
+  }
+}

package/native/core/programmers/llm/LlmApplicationProgrammer.go

@@ -401,6 +401,7 @@ func llmApplicationProgrammer_convertParameters(
   output := llmSchemaProgrammer_convert_schema_config(target, components, defs, config)
   output["additionalProperties"] = false
   output["$defs"] = defs
+  llmReferenceDescription_assign(output, schema, components)
   return output
 }