typia 13.0.0-dev.20260427-2 → 13.0.0-dev.20260430

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

@@ -0,0 +1,179 @@
+package iterate
+
+import (
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
+)
+
+func json_schema_object(props struct {
+	components *OpenApi_IComponents
+	object     *nativemetadata.MetadataObject
+}) []JsonSchema {
+	return json_schema_plugin(struct {
+		schema JsonSchema
+		tags   [][]nativemetadata.IMetadataTypeTag
+	}{
+		schema: json_schema_emplace_object(props),
+		tags:   props.object.Tags,
+	})
+}
+
+func json_schema_emplace_object(props struct {
+	components *OpenApi_IComponents
+	object     *nativemetadata.MetadataObject
+}) JsonSchema {
+	if props.object.Type.IsLiteral() {
+		return json_schema_create_object_schema(props)
+	}
+	key := props.object.Type.Name
+	ref := "#/components/schemas/" + key
+	if props.components.Schemas != nil {
+		if _, ok := props.components.Schemas[key]; ok {
+			return JsonSchema{"$ref": ref}
+		}
+	}
+	if props.components.Schemas == nil {
+		props.components.Schemas = map[string]JsonSchema{}
+	}
+	lazy := JsonSchema{}
+	props.components.Schemas[key] = lazy
+	json_schema_assign(lazy, json_schema_create_object_schema(props))
+	return JsonSchema{"$ref": ref}
+}
+
+func json_schema_create_object_schema(props struct {
+	components *OpenApi_IComponents
+	object     *nativemetadata.MetadataObject
+}) JsonSchema {
+	properties := JsonSchema{}
+	extraMeta := json_schema_superfluous{
+		patternProperties: map[string]json_schema_metadata_schema_pair{},
+	}
+	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 {
+			continue
+		}
+		if json_schema_has_any_tag(property.JsDocTags, []string{"hidden", "ignore", "internal"}) {
+			continue
+		}
+
+		attribute := JsonSchema{}
+		if json_schema_has_tag(property.JsDocTags, "deprecated") {
+			attribute["deprecated"] = true
+		}
+		if title := json_schema_title(struct {
+			description *string
+			jsDocTags   []nativemetadata.IJsDocTagInfo
+		}{description: property.Description, jsDocTags: property.JsDocTags}); title != nil {
+			attribute["title"] = *title
+		}
+		if description := json_schema_description(struct {
+			description *string
+			jsDocTags   []nativemetadata.IJsDocTagInfo
+		}{description: property.Description, jsDocTags: property.JsDocTags}); description != nil {
+			attribute["description"] = *description
+		}
+		if property.Mutability != nil && *property.Mutability == "readonly" {
+			attribute["readOnly"] = true
+		}
+		value := json_schema_station(json_schema_station_props{
+			blockNever: true,
+			components: props.components,
+			attribute:  attribute,
+			metadata:   property.Value,
+		})
+		if value == nil {
+			continue
+		}
+		json_schema_jsDocTags(value, property.JsDocTags)
+
+		key := property.Key.GetSoleLiteral()
+		if key != nil {
+			properties[*key] = value
+			if property.Value.IsRequired() {
+				required = append(required, *key)
+			}
+		} else {
+			pattern := metadata_to_pattern(struct {
+				top      bool
+				metadata *nativemetadata.MetadataSchema
+			}{top: true, metadata: property.Key})
+			pair := json_schema_metadata_schema_pair{metadata: property.Value, schema: value}
+			if pattern == nativeutils.PatternUtil.STRING {
+				extraMeta.additionalProperties = &pair
+			} else {
+				extraMeta.patternProperties[pattern] = pair
+			}
+		}
+	}
+
+	schema := JsonSchema{
+		"type":                 "object",
+		"properties":           properties,
+		"required":             required,
+		"additionalProperties": false,
+	}
+	if title := json_schema_title(struct {
+		description *string
+		jsDocTags   []nativemetadata.IJsDocTagInfo
+	}{description: props.object.Type.Description, jsDocTags: props.object.Type.JsDocTags}); title != nil {
+		schema["title"] = *title
+	}
+	if description := json_schema_description(struct {
+		description *string
+		jsDocTags   []nativemetadata.IJsDocTagInfo
+	}{description: props.object.Type.Description, jsDocTags: props.object.Type.JsDocTags}); description != nil {
+		schema["description"] = *description
+	}
+	if additional := json_schema_join(struct {
+		components *OpenApi_IComponents
+		extra      json_schema_superfluous
+	}{components: props.components, extra: extraMeta}); additional != nil {
+		schema["additionalProperties"] = additional
+	}
+	return json_schema_jsDocTags(schema, props.object.Type.JsDocTags)
+}
+
+func json_schema_join(props struct {
+	components *OpenApi_IComponents
+	extra      json_schema_superfluous
+}) JsonSchema {
+	elements := []json_schema_metadata_schema_pair{}
+	for _, value := range props.extra.patternProperties {
+		elements = append(elements, value)
+	}
+	if props.extra.additionalProperties != nil {
+		elements = append(elements, *props.extra.additionalProperties)
+	}
+	if len(elements) == 0 {
+		return nil
+	}
+	if len(elements) == 1 {
+		return elements[0].schema
+	}
+	metadata := elements[0].metadata
+	for i := 1; i < len(elements); i++ {
+		metadata = nativemetadata.MetadataSchema_merge(metadata, elements[i].metadata)
+	}
+	return json_schema_station(json_schema_station_props{
+		blockNever: true,
+		components: props.components,
+		attribute:  JsonSchema{},
+		metadata:   metadata,
+	})
+}
+
+type json_schema_superfluous struct {
+	additionalProperties *json_schema_metadata_schema_pair
+	patternProperties    map[string]json_schema_metadata_schema_pair
+}
+
+type json_schema_metadata_schema_pair struct {
+	metadata *nativemetadata.MetadataSchema
+	schema   JsonSchema
+}

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

@@ -0,0 +1,47 @@
+package iterate
+
+import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+type JsonSchema map[string]any
+
+func json_schema_plugin(props struct {
+	schema JsonSchema
+	tags   [][]nativemetadata.IMetadataTypeTag
+}) []JsonSchema {
+	plugins := make([][]nativemetadata.IMetadataTypeTag, 0)
+	for _, row := range props.tags {
+		filtered := make([]nativemetadata.IMetadataTypeTag, 0)
+		for _, tag := range row {
+			if tag.Schema != nil {
+				filtered = append(filtered, tag)
+			}
+		}
+		if len(filtered) != 0 {
+			plugins = append(plugins, filtered)
+		}
+	}
+	if len(plugins) == 0 {
+		return []JsonSchema{props.schema}
+	}
+	output := make([]JsonSchema, 0, len(plugins))
+	for _, row := range plugins {
+		base := cloneJsonSchema(props.schema)
+		for _, tag := range row {
+			if schema, ok := tag.Schema.(map[string]any); ok {
+				for key, value := range schema {
+					base[key] = value
+				}
+			}
+		}
+		output = append(output, base)
+	}
+	return output
+}
+
+func cloneJsonSchema(input JsonSchema) JsonSchema {
+	output := JsonSchema{}
+	for key, value := range input {
+		output[key] = value
+	}
+	return output
+}

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

@@ -0,0 +1,251 @@
+package iterate
+
+import (
+	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type json_schema_station_props struct {
+	blockNever bool
+	components *OpenApi_IComponents
+	attribute  JsonSchema
+	metadata   *nativemetadata.MetadataSchema
+}
+
+type Json_schema_station_props struct {
+	BlockNever bool
+	Components *OpenApi_IComponents
+	Attribute  JsonSchema
+	Metadata   *nativemetadata.MetadataSchema
+}
+
+func Json_schema_station(props Json_schema_station_props) JsonSchema {
+	return json_schema_station(json_schema_station_props{
+		blockNever: props.BlockNever,
+		components: props.Components,
+		attribute:  props.Attribute,
+		metadata:   props.Metadata,
+	})
+}
+
+func json_schema_station(props json_schema_station_props) JsonSchema {
+	if props.metadata.Any {
+		output := cloneJsonSchema(props.attribute)
+		if _, ok := output["type"]; ok == false {
+			output["type"] = nil
+		}
+		return output
+	}
+
+	union := []JsonSchema{}
+	insert := func(schema JsonSchema) {
+		if schema != nil {
+			union = append(union, schema)
+		}
+	}
+
+	if props.metadata.Nullable {
+		insert(JsonSchema{"type": "null"})
+	}
+	if props.metadata.Escaped != nil {
+		for _, schema := range json_schema_escaped(struct {
+			components *OpenApi_IComponents
+			escaped    *nativemetadata.MetadataEscaped
+		}{components: props.components, escaped: props.metadata.Escaped}) {
+			insert(schema)
+		}
+	}
+	if len(props.metadata.Templates) != 0 && nativehelpers.AtomicPredicator.Template(props.metadata) {
+		for _, schema := range json_schema_templates(props.metadata) {
+			insert(schema)
+		}
+	}
+	for _, constant := range props.metadata.Constants {
+		if nativehelpers.AtomicPredicator.Constant(struct {
+			Metadata *nativemetadata.MetadataSchema
+			Name     string
+		}{Metadata: props.metadata, Name: constant.Type}) == false {
+			continue
+		}
+		for _, schema := range json_schema_constant(constant) {
+			insert(schema)
+		}
+	}
+	for _, atomic := range props.metadata.Atomics {
+		if atomic.Type == "boolean" {
+			for _, schema := range json_schema_boolean(atomic) {
+				insert(schema)
+			}
+		} else if atomic.Type == "bigint" {
+			for _, schema := range json_schema_bigint(atomic) {
+				insert(schema)
+			}
+		} else if atomic.Type == "number" {
+			for _, schema := range json_schema_number(atomic) {
+				insert(schema)
+			}
+		} else if atomic.Type == "string" {
+			for _, schema := range json_schema_string(atomic) {
+				insert(schema)
+			}
+		}
+	}
+	for _, array := range props.metadata.Arrays {
+		for _, schema := range json_schema_array(struct {
+			components *OpenApi_IComponents
+			array      *nativemetadata.MetadataArray
+		}{components: props.components, array: array}) {
+			insert(schema)
+		}
+	}
+	for _, tuple := range props.metadata.Tuples {
+		insert(json_schema_tuple(struct {
+			components *OpenApi_IComponents
+			tuple      *nativemetadata.MetadataTuple
+		}{components: props.components, tuple: tuple}))
+	}
+	for _, native := range props.metadata.Natives {
+		if nativehelpers.AtomicPredicator.Native(native.Name) {
+			typ := lowerAscii(native.Name)
+			if json_schema_station_has_atomic(props.metadata, typ) {
+				continue
+			}
+			atomic := nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: typ, Tags: [][]nativemetadata.IMetadataTypeTag{}})
+			if typ == "boolean" {
+				for _, schema := range json_schema_boolean(atomic) {
+					insert(schema)
+				}
+			} else if typ == "bigint" {
+				for _, schema := range json_schema_bigint(atomic) {
+					insert(schema)
+				}
+			} else if typ == "number" {
+				for _, schema := range json_schema_number(atomic) {
+					insert(schema)
+				}
+			} else if typ == "string" {
+				for _, schema := range json_schema_string(atomic) {
+					insert(schema)
+				}
+			}
+		} else {
+			for _, schema := range json_schema_native(struct {
+				components *OpenApi_IComponents
+				native     *nativemetadata.MetadataNative
+			}{components: props.components, native: native}) {
+				insert(schema)
+			}
+		}
+	}
+	if len(props.metadata.Sets) != 0 {
+		for _, schema := range json_schema_native(struct {
+			components *OpenApi_IComponents
+			native     *nativemetadata.MetadataNative
+		}{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Set", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
+			insert(schema)
+		}
+	}
+	if len(props.metadata.Maps) != 0 {
+		for _, schema := range json_schema_native(struct {
+			components *OpenApi_IComponents
+			native     *nativemetadata.MetadataNative
+		}{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Map", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
+			insert(schema)
+		}
+	}
+	for _, object := range props.metadata.Objects {
+		for _, schema := range json_schema_object(struct {
+			components *OpenApi_IComponents
+			object     *nativemetadata.MetadataObject
+		}{components: props.components, object: object}) {
+			insert(schema)
+		}
+	}
+	for _, alias := range props.metadata.Aliases {
+		for _, schema := range json_schema_alias(struct {
+			blockNever bool
+			components *OpenApi_IComponents
+			alias      *nativemetadata.MetadataAlias
+		}{blockNever: props.blockNever, components: props.components, alias: alias}) {
+			insert(schema)
+		}
+	}
+
+	if len(union) == 0 && props.blockNever {
+		return nil
+	}
+	var schema JsonSchema
+	if len(union) == 0 {
+		schema = JsonSchema{"type": nil}
+	} else if len(union) == 1 {
+		schema = union[0]
+	} else {
+		schema = JsonSchema{"oneOf": union}
+		if discriminator := json_schema_discriminator(props.metadata); discriminator != nil {
+			schema["discriminator"] = discriminator
+		}
+	}
+	return json_schema_station_mergeAttribute(schema, props.attribute)
+}
+
+func json_schema_station_has_atomic(metadata *nativemetadata.MetadataSchema, typ string) bool {
+	for _, atomic := range metadata.Atomics {
+		if atomic.Type == typ {
+			return true
+		}
+	}
+	return false
+}
+
+func json_schema_station_mergeAttribute(schema JsonSchema, attribute JsonSchema) JsonSchema {
+	output := cloneJsonSchema(schema)
+	for key, value := range attribute {
+		output[key] = value
+	}
+	for _, key := range []string{"title", "description", "deprecated"} {
+		if _, ok := attribute[key]; ok == false {
+			if value, ok := schema[key]; ok {
+				output[key] = value
+			}
+		}
+	}
+	return output
+}
+
+func json_schema_assign(target JsonSchema, source JsonSchema) {
+	for key, value := range source {
+		target[key] = value
+	}
+}
+
+func json_schema_is_string(schema JsonSchema) bool {
+	return schema["type"] == "string"
+}
+
+func json_schema_has_tag(tags []nativemetadata.IJsDocTagInfo, name string) bool {
+	for _, tag := range tags {
+		if tag.Name == name {
+			return true
+		}
+	}
+	return false
+}
+
+func json_schema_has_any_tag(tags []nativemetadata.IJsDocTagInfo, names []string) bool {
+	for _, name := range names {
+		if json_schema_has_tag(tags, name) {
+			return true
+		}
+	}
+	return false
+}
+
+func lowerAscii(str string) string {
+	bytes := []byte(str)
+	for i, ch := range bytes {
+		if 'A' <= ch && ch <= 'Z' {
+			bytes[i] = ch + ('a' - 'A')
+		}
+	}
+	return string(bytes)
+}

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

@@ -0,0 +1,17 @@
+package iterate
+
+import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+func json_schema_string(atomic *nativemetadata.MetadataAtomic) []JsonSchema {
+	return json_schema_plugin(struct {
+		schema JsonSchema
+		tags   [][]nativemetadata.IMetadataTypeTag
+	}{
+		schema: JsonSchema{"type": "string"},
+		tags:   atomic.Tags,
+	})
+}
+
+func Json_schema_string_export(atomic *nativemetadata.MetadataAtomic) []JsonSchema {
+	return json_schema_string(atomic)
+}

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

@@ -0,0 +1,63 @@
+package iterate
+
+import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+func json_schema_templates(metadata *nativemetadata.MetadataSchema) []JsonSchema {
+	pureTemplates := []*nativemetadata.MetadataTemplate{}
+	taggedTemplates := []*nativemetadata.MetadataTemplate{}
+	for _, tpl := range metadata.Templates {
+		if json_schema_template_isPure(tpl.Tags) {
+			pureTemplates = append(pureTemplates, tpl)
+		} else {
+			taggedTemplates = append(taggedTemplates, tpl)
+		}
+	}
+
+	output := []JsonSchema{}
+	if len(pureTemplates) != 0 {
+		meta := nativemetadata.MetadataSchema_initialize()
+		meta.Templates = pureTemplates
+		output = append(output, JsonSchema{
+			"type": "string",
+			"pattern": metadata_to_pattern(struct {
+				top      bool
+				metadata *nativemetadata.MetadataSchema
+			}{
+				top:      true,
+				metadata: meta,
+			}),
+		})
+	}
+	for _, tpl := range taggedTemplates {
+		meta := nativemetadata.MetadataSchema_initialize()
+		meta.Templates = []*nativemetadata.MetadataTemplate{tpl}
+		output = append(output, json_schema_plugin(struct {
+			schema JsonSchema
+			tags   [][]nativemetadata.IMetadataTypeTag
+		}{
+			schema: JsonSchema{
+				"type": "string",
+				"pattern": metadata_to_pattern(struct {
+					top      bool
+					metadata *nativemetadata.MetadataSchema
+				}{
+					top:      false,
+					metadata: meta,
+				}),
+			},
+			tags: tpl.Tags,
+		})...)
+	}
+	return output
+}
+
+func json_schema_template_isPure(matrix [][]nativemetadata.IMetadataTypeTag) bool {
+	for _, tags := range matrix {
+		for _, tag := range tags {
+			if tag.Schema != nil {
+				return false
+			}
+		}
+	}
+	return true
+}

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

@@ -0,0 +1,25 @@
+package iterate
+
+import (
+	"strings"
+
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+func json_schema_title(schema struct {
+	description *string
+	jsDocTags   []nativemetadata.IJsDocTagInfo
+}) *string {
+	for _, tag := range schema.jsDocTags {
+		if tag.Name != "title" || len(tag.Text) == 0 {
+			continue
+		}
+		parts := make([]string, 0, len(tag.Text))
+		for _, part := range tag.Text {
+			parts = append(parts, strings.ReplaceAll(part.Text, "\r\n", "\n"))
+		}
+		output := strings.Join(parts, "")
+		return &output
+	}
+	return nil
+}

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

@@ -0,0 +1,41 @@
+package iterate
+
+import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+func json_schema_tuple(props struct {
+	components *OpenApi_IComponents
+	tuple      *nativemetadata.MetadataTuple
+}) JsonSchema {
+	var tail *nativemetadata.MetadataSchema
+	if len(props.tuple.Type.Elements) != 0 {
+		tail = props.tuple.Type.Elements[len(props.tuple.Type.Elements)-1].Rest
+	}
+	prefixItems := props.tuple.Type.Elements
+	if props.tuple.Type.IsRest() && len(prefixItems) != 0 {
+		prefixItems = prefixItems[:len(prefixItems)-1]
+	}
+	items := []JsonSchema{}
+	for _, metadata := range prefixItems {
+		items = append(items, json_schema_station(json_schema_station_props{
+			blockNever: false,
+			components: props.components,
+			metadata:   metadata,
+			attribute:  JsonSchema{},
+		}))
+	}
+	schema := JsonSchema{
+		"type":        "array",
+		"prefixItems": items,
+	}
+	if tail != nil {
+		schema["additionalItems"] = json_schema_station(json_schema_station_props{
+			blockNever: false,
+			components: props.components,
+			metadata:   tail,
+			attribute:  JsonSchema{},
+		})
+	} else {
+		schema["additionalItems"] = false
+	}
+	return schema
+}

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

@@ -0,0 +1,64 @@
+package iterate
+
+import (
+	"fmt"
+	"strings"
+
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
+)
+
+func metadata_to_pattern(props struct {
+	top      bool
+	metadata *nativemetadata.MetadataSchema
+}) string {
+	for _, atomic := range props.metadata.Atomics {
+		if atomic.Type == "string" {
+			return "(.*)"
+		}
+	}
+
+	values := []string{}
+	for _, constant := range props.metadata.Constants {
+		if constant.Type != "string" {
+			for _, value := range constant.Values {
+				values = append(values, fmt.Sprint(value.Value))
+			}
+			continue
+		}
+		for _, value := range constant.Values {
+			if str, ok := value.Value.(string); ok {
+				values = append(values, nativeutils.PatternUtil.Escape(str))
+			} else {
+				values = append(values, nativeutils.PatternUtil.Escape(fmt.Sprint(value.Value)))
+			}
+		}
+	}
+	for _, atomic := range props.metadata.Atomics {
+		if atomic.Type == "number" || atomic.Type == "bigint" {
+			values = append(values, nativeutils.PatternUtil.NUMBER)
+		} else if atomic.Type == "boolean" {
+			values = append(values, nativeutils.PatternUtil.BOOLEAN)
+		}
+	}
+	for _, template := range props.metadata.Templates {
+		values = append(values, "("+template_to_pattern(struct {
+			top      bool
+			template []*nativemetadata.MetadataSchema
+		}{
+			top:      false,
+			template: template.Row,
+		})+")")
+	}
+
+	pattern := ""
+	if len(values) == 1 {
+		pattern = values[0]
+	} else {
+		pattern = "(" + strings.Join(values, "|") + ")"
+	}
+	if props.top {
+		return nativeutils.PatternUtil.Fix(pattern)
+	}
+	return pattern
+}

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

@@ -0,0 +1,12 @@
+package iterate
+
+func postfix_of_tuple(str string) string {
+	if len(str) > 0 && str[len(str)-1] == '"' {
+		return str[:len(str)-1]
+	}
+	return str + " + \""
+}
+
+func Postfix_of_tuple_export(str string) string {
+	return postfix_of_tuple(str)
+}