typia 13.1.1 → 13.2.0

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

@@ -0,0 +1,205 @@
+package iterate
+
+import (
+  "testing"
+
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestJsonSchemaDiscriminatorDeclarationSyntax verifies discriminator eligibility ignores declaration syntax.
+//
+// A union member declared with `interface` lands in `MetadataSchema.Objects`
+// while a `type` alias of an object literal lands in `MetadataSchema.Aliases`,
+// yet both export the very same `$ref`. The gate used to compare `Size()` with
+// `len(Objects)` alone, so a single alias member silently dropped the whole
+// union's discriminator. Eligibility must depend on every member resolving to a
+// referenced object type carrying a common literal tag, never on which bucket
+// the metadata factory happened to file it under.
+//
+// 1. Build the interface, alias, and mixed forms of one tagged union.
+// 2. Assert each emits the identical propertyName and mapping.
+// 3. Assert the negative shapes -- no common tag, a non-object member, a
+//    literal (inline) member, and an alias that does not name a lone object --
+//    still emit no discriminator, so the resolution cannot over-emit.
+func TestJsonSchemaDiscriminatorDeclarationSyntax(t *testing.T) {
+  circle := func() *nativemetadata.MetadataObject {
+    return discriminatorObject("Circle", "type", "circle")
+  }
+  square := func() *nativemetadata.MetadataObject {
+    return discriminatorObject("Square", "type", "square")
+  }
+
+  expected := JsonSchema{
+    "propertyName": "type",
+    "mapping": JsonSchema{
+      "circle": "#/components/schemas/Circle",
+      "square": "#/components/schemas/Square",
+    },
+  }
+
+  positives := []struct {
+    label    string
+    metadata *nativemetadata.MetadataSchema
+  }{
+    {
+      label:    "interface | interface",
+      metadata: discriminatorSchema([]*nativemetadata.MetadataObject{circle(), square()}, nil),
+    },
+    {
+      label: "alias | alias",
+      metadata: discriminatorSchema(nil, []*nativemetadata.MetadataAlias{
+        discriminatorAlias("Circle", circle()),
+        discriminatorAlias("Square", square()),
+      }),
+    },
+    {
+      label: "interface | alias",
+      metadata: discriminatorSchema(
+        []*nativemetadata.MetadataObject{circle()},
+        []*nativemetadata.MetadataAlias{discriminatorAlias("Square", square())},
+      ),
+    },
+  }
+  for _, positive := range positives {
+    actual := json_schema_discriminator(positive.metadata)
+    if actual == nil {
+      t.Fatalf("%s: discriminator must be emitted regardless of declaration syntax", positive.label)
+    }
+    if actual["propertyName"] != expected["propertyName"] {
+      t.Fatalf("%s: propertyName mismatch: %v", positive.label, actual["propertyName"])
+    }
+    mapping, ok := actual["mapping"].(JsonSchema)
+    if ok == false {
+      t.Fatalf("%s: mapping must be a JSON schema object", positive.label)
+    }
+    want := expected["mapping"].(JsonSchema)
+    if len(mapping) != len(want) {
+      t.Fatalf("%s: mapping size mismatch: %v", positive.label, mapping)
+    }
+    for key, value := range want {
+      if mapping[key] != value {
+        t.Fatalf("%s: mapping[%s] mismatch: %v", positive.label, key, mapping[key])
+      }
+    }
+  }
+
+  literal := discriminatorObject("__type", "type", "circle")
+  atomic := nativemetadata.MetadataSchema_initialize()
+  atomic.Atomics = append(atomic.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "string"}))
+
+  nonObjectAlias := discriminatorSchema(nil, []*nativemetadata.MetadataAlias{
+    discriminatorAlias("Circle", circle()),
+    nativemetadata.MetadataAlias_create(nativemetadata.MetadataAlias{
+      Type: nativemetadata.MetadataAliasType_create(nativemetadata.MetadataAliasType{
+        Name:  "Name",
+        Value: atomic,
+      }),
+    }),
+  })
+  // an alias naming another alias exports a $ref to the outer alias rather than
+  // to an object, so resolving through it would target a name `oneOf` never
+  // emits -- a wrong mapping instead of a missing one
+  nestedValue := nativemetadata.MetadataSchema_initialize()
+  nestedValue.Aliases = append(nestedValue.Aliases, discriminatorAlias("Square", square()))
+  nestedAlias := discriminatorSchema(nil, []*nativemetadata.MetadataAlias{
+    discriminatorAlias("Circle", circle()),
+    nativemetadata.MetadataAlias_create(nativemetadata.MetadataAlias{
+      Type: nativemetadata.MetadataAliasType_create(nativemetadata.MetadataAliasType{
+        Name:  "SquareAlias",
+        Value: nestedValue,
+      }),
+    }),
+  })
+  withAtomic := discriminatorSchema(nil, []*nativemetadata.MetadataAlias{
+    discriminatorAlias("Circle", circle()),
+    discriminatorAlias("Square", square()),
+  })
+  withAtomic.Atomics = append(withAtomic.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "string"}))
+
+  negatives := []struct {
+    label    string
+    metadata *nativemetadata.MetadataSchema
+  }{
+    {
+      label:    "empty",
+      metadata: discriminatorSchema(nil, nil),
+    },
+    {
+      label: "no common literal tag",
+      metadata: discriminatorSchema(nil, []*nativemetadata.MetadataAlias{
+        discriminatorAlias("Circle", discriminatorObject("Circle", "kind", "circle")),
+        discriminatorAlias("Square", discriminatorObject("Square", "name", "square")),
+      }),
+    },
+    {
+      label:    "non-object member beside aliases",
+      metadata: withAtomic,
+    },
+    {
+      label:    "alias naming a non-object value",
+      metadata: nonObjectAlias,
+    },
+    {
+      label:    "alias naming another alias",
+      metadata: nestedAlias,
+    },
+    {
+      label: "literal (inline) alias member",
+      metadata: discriminatorSchema(nil, []*nativemetadata.MetadataAlias{
+        discriminatorAlias("__type", literal),
+        discriminatorAlias("Square", square()),
+      }),
+    },
+  }
+  for _, negative := range negatives {
+    if actual := json_schema_discriminator(negative.metadata); actual != nil {
+      t.Fatalf("%s: discriminator must stay absent, got %v", negative.label, actual)
+    }
+  }
+}
+
+func discriminatorSchema(
+  objects []*nativemetadata.MetadataObject,
+  aliases []*nativemetadata.MetadataAlias,
+) *nativemetadata.MetadataSchema {
+  meta := nativemetadata.MetadataSchema_initialize()
+  meta.Objects = append(meta.Objects, objects...)
+  meta.Aliases = append(meta.Aliases, aliases...)
+  return meta
+}
+
+func discriminatorAlias(name string, object *nativemetadata.MetadataObject) *nativemetadata.MetadataAlias {
+  value := nativemetadata.MetadataSchema_initialize()
+  value.Objects = append(value.Objects, object)
+  return nativemetadata.MetadataAlias_create(nativemetadata.MetadataAlias{
+    Type: nativemetadata.MetadataAliasType_create(nativemetadata.MetadataAliasType{
+      Name:  name,
+      Value: value,
+    }),
+  })
+}
+
+func discriminatorObject(name string, key string, value string) *nativemetadata.MetadataObject {
+  return nativemetadata.MetadataObject_create(nativemetadata.MetadataObject{
+    Type: nativemetadata.MetadataObjectType_create(nativemetadata.MetadataObjectType{
+      Name: name,
+      Properties: []*nativemetadata.MetadataProperty{
+        nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{
+          Key:   discriminatorLiteral(key),
+          Value: discriminatorLiteral(value),
+        }),
+      },
+    }),
+  })
+}
+
+func discriminatorLiteral(value string) *nativemetadata.MetadataSchema {
+  meta := nativemetadata.MetadataSchema_initialize()
+  meta.Constants = append(meta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
+    Type: "string",
+    Values: []*nativemetadata.MetadataConstantValue{
+      nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: value}),
+    },
+  }))
+  return meta
+}

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

@@ -55,10 +55,16 @@ func json_schema_create_object_schema(props struct {
   required := []string{}
 
   for _, property := range props.object.Type.Properties {
-    if len(property.Value.Functions) != 0 &&
-      property.Value.Nullable == false &&
-      property.Value.IsRequired() &&
-      property.Value.Size() == 0 {
+    // A member that is only a function has no JSON to describe, so the schema
+    // drops it exactly as the serializer does. The condition has to match the
+    // serializer's (`StringifyJoiner`) or the two disagree about the same type:
+    // `Size()` counts `Functions`, so a pure function member is size 1 and a
+    // `Size() == 0` test could never fire for the case it was written to catch,
+    // leaving the member described as a `$ref` to an empty component — a schema
+    // for a document `json.stringify` never produces. Optionality is not part of
+    // the question either; an optional function member has no JSON either
+    // (samchon/typia#2270).
+    if json_schema_object_function_only(property.Value) {
       continue
     }
     if json_schema_has_any_tag(property.JsDocTags, []string{"hidden", "ignore", "internal"}) {
@@ -111,7 +117,7 @@ func json_schema_create_object_schema(props struct {
       if pattern == nativeutils.PatternUtil.STRING {
         extraMeta.additionalProperties = &pair
       } else {
-        extraMeta.patternProperties[pattern] = pair
+        extraMeta.setPatternProperty(pattern, pair)
       }
     }
   }
@@ -152,8 +158,8 @@ func json_schema_join(props struct {
   extra      json_schema_superfluous
 }) JsonSchema {
   elements := []json_schema_metadata_schema_pair{}
-  for _, value := range props.extra.patternProperties {
-    elements = append(elements, value)
+  for _, key := range props.extra.patternPropertyKeys {
+    elements = append(elements, props.extra.patternProperties[key])
   }
   if props.extra.additionalProperties != nil {
     elements = append(elements, *props.extra.additionalProperties)
@@ -179,9 +185,45 @@ func json_schema_join(props struct {
 type json_schema_superfluous struct {
   additionalProperties *json_schema_metadata_schema_pair
   patternProperties    map[string]json_schema_metadata_schema_pair
+  // patternPropertyKeys preserves the first-insertion order of the map while
+  // later assignments to an existing pattern replace its value in place.
+  patternPropertyKeys []string
+}
+
+func (superfluous *json_schema_superfluous) setPatternProperty(pattern string, pair json_schema_metadata_schema_pair) {
+  if _, exists := superfluous.patternProperties[pattern]; exists == false {
+    superfluous.patternPropertyKeys = append(superfluous.patternPropertyKeys, pattern)
+  }
+  superfluous.patternProperties[pattern] = pair
 }
 
 type json_schema_metadata_schema_pair struct {
   metadata *nativemetadata.MetadataSchema
   schema   JsonSchema
 }
+
+// json_schema_object_function_only reports whether a member has no JSON to
+// describe because it is only a function, so the schema drops it exactly as the
+// serializer does.
+//
+// The condition has to agree with the serializer's (`StringifyJoiner`) or the
+// two describe the same type differently. Two ways it disagreed: `Size()` counts
+// `Functions`, so a pure function member is size 1 and the previous
+// `Size() == 0` test could never fire for the case it was written to catch; and
+// a named alias of a function type carries `Aliases`, not `Functions`, so the
+// same type reached through `type Consumer = (v: number) => string` survived as
+// a `$ref` to an empty component while the interface spelling of it vanished —
+// two documents for one type, and neither `json.stringify` ever produces
+// (samchon/typia#2270).
+//
+// Optionality is deliberately not part of the question: an optional function
+// member has no JSON either.
+func json_schema_object_function_only(value *nativemetadata.MetadataSchema) bool {
+  if value == nil {
+    return false
+  }
+  resolved := nativemetadata.MetadataSchema_unalias(value)
+  return len(resolved.Functions) != 0 &&
+    resolved.Nullable == false &&
+    resolved.Size() == 1
+}

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

@@ -0,0 +1,44 @@
+package iterate
+
+import (
+  "slices"
+  "testing"
+
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestJsonSchemaPatternPropertyOrderPreservesFirstPosition verifies repeated patterns keep one ordered slot.
+//
+// The legacy TypeScript producer stored pairs in a plain object: assigning an
+// existing pattern replaced its value without moving or duplicating its first
+// insertion position. The Go order record must preserve that overwrite contract.
+//
+//  1. Insert two patterns, then replace the first pattern with new metadata and schema values.
+//  2. Assert the ordered keys remain unique and the map retains the replacement pair.
+func TestJsonSchemaPatternPropertyOrderPreservesFirstPosition(t *testing.T) {
+  first := &nativemetadata.MetadataSchema{}
+  replacement := &nativemetadata.MetadataSchema{}
+  extra := json_schema_superfluous{
+    patternProperties: map[string]json_schema_metadata_schema_pair{},
+  }
+  extra.setPatternProperty("first", json_schema_metadata_schema_pair{
+    metadata: first,
+    schema:   JsonSchema{"type": "string"},
+  })
+  extra.setPatternProperty("second", json_schema_metadata_schema_pair{
+    metadata: &nativemetadata.MetadataSchema{},
+    schema:   JsonSchema{"type": "boolean"},
+  })
+  extra.setPatternProperty("first", json_schema_metadata_schema_pair{
+    metadata: replacement,
+    schema:   JsonSchema{"type": "number"},
+  })
+
+  if slices.Equal(extra.patternPropertyKeys, []string{"first", "second"}) == false {
+    t.Fatalf("pattern property order was %v", extra.patternPropertyKeys)
+  }
+  pair := extra.patternProperties["first"]
+  if pair.metadata != replacement || pair.schema["type"] != "number" {
+    t.Fatalf("replacement pair was not retained: %#v", pair)
+  }
+}