@nestia/core 11.2.0 → 12.0.0-dev.20260520.1

package/native/cmd/ttsc-nestia/sdk_metadata_json.go

@@ -0,0 +1,327 @@
+package main
+
+import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+func nestiaSDKMetadataComponentsLiteral(
+	components schemametadata.IMetadataComponents,
+) map[string]any {
+	return map[string]any{
+		"objects": nestiaSDKMetadataObjectTypes(components.Objects),
+		"aliases": nestiaSDKMetadataAliasTypes(components.Aliases),
+		"arrays":  nestiaSDKMetadataArrayTypes(components.Arrays),
+		"tuples":  nestiaSDKMetadataTupleTypes(components.Tuples),
+	}
+}
+
+func nestiaSDKMetadataSchemaLiteral(meta *schemametadata.IMetadataSchema) any {
+	if meta == nil {
+		return nestiaSDKLiteralNull
+	}
+	return map[string]any{
+		"any":       meta.Any,
+		"required":  meta.Required,
+		"optional":  meta.Optional,
+		"nullable":  meta.Nullable,
+		"functions": nestiaSDKMetadataFunctions(meta.Functions),
+		"atomics":   nestiaSDKMetadataAtomics(meta.Atomics),
+		"constants": nestiaSDKMetadataConstants(meta.Constants),
+		"templates": nestiaSDKMetadataTemplates(meta.Templates),
+		"escaped":   nestiaSDKMetadataEscaped(meta.Escaped),
+		"rest":      nestiaSDKMetadataSchemaLiteral(meta.Rest),
+		"arrays":    nestiaSDKMetadataReferences(meta.Arrays),
+		"tuples":    nestiaSDKMetadataReferences(meta.Tuples),
+		"objects":   nestiaSDKMetadataReferences(meta.Objects),
+		"aliases":   nestiaSDKMetadataReferences(meta.Aliases),
+		"natives":   nestiaSDKMetadataReferences(meta.Natives),
+		"sets":      nestiaSDKMetadataSets(meta.Sets),
+		"maps":      nestiaSDKMetadataMaps(meta.Maps),
+	}
+}
+
+func nestiaSDKMetadataFunctions(
+	input []*schemametadata.IMetadataSchema_IFunction,
+) []any {
+	output := []any{}
+	for _, fn := range input {
+		if fn == nil {
+			continue
+		}
+		output = append(output, map[string]any{
+			"parameters": nestiaSDKMetadataParameters(fn.Parameters),
+			"output":     nestiaSDKMetadataSchemaLiteral(fn.Output),
+			"async":      fn.Async,
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataParameters(
+	input []*schemametadata.IMetadataSchema_IParameter,
+) []any {
+	output := []any{}
+	for _, param := range input {
+		if param == nil {
+			continue
+		}
+		output = append(output, map[string]any{
+			"name":        param.Name,
+			"type":        nestiaSDKMetadataSchemaLiteral(param.Type),
+			"description": nestiaSDKOptionalString(param.Description),
+			"jsDocTags":   nestiaSDKJSDocTags(param.JsDocTags),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataAtomics(
+	input []schemametadata.IMetadataSchema_IAtomic,
+) []any {
+	output := []any{}
+	for _, atomic := range input {
+		output = append(output, map[string]any{
+			"type": atomic.Type,
+			"tags": nestiaSDKMetadataTagMatrix(atomic.Tags),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataConstants(
+	input []schemametadata.IMetadataSchema_IConstant,
+) []any {
+	output := []any{}
+	for _, constant := range input {
+		values := []any{}
+		for _, value := range constant.Values {
+			values = append(values, map[string]any{
+				"value":       value.Value,
+				"tags":        nestiaSDKMetadataTagMatrix(value.Tags),
+				"description": nestiaSDKOptionalString(value.Description),
+				"jsDocTags":   nestiaSDKJSDocTags(value.JsDocTags),
+			})
+		}
+		output = append(output, map[string]any{
+			"type":   constant.Type,
+			"values": values,
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataTemplates(
+	input []schemametadata.IMetadataSchema_ITemplate,
+) []any {
+	output := []any{}
+	for _, template := range input {
+		row := []any{}
+		for _, child := range template.Row {
+			row = append(row, nestiaSDKMetadataSchemaLiteral(child))
+		}
+		output = append(output, map[string]any{
+			"row":  row,
+			"tags": nestiaSDKMetadataTagMatrix(template.Tags),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataEscaped(
+	input *schemametadata.IMetadataSchema_IEscaped,
+) any {
+	if input == nil {
+		return nestiaSDKLiteralNull
+	}
+	return map[string]any{
+		"original": nestiaSDKMetadataSchemaLiteral(input.Original),
+		"returns":  nestiaSDKMetadataSchemaLiteral(input.Returns),
+	}
+}
+
+func nestiaSDKMetadataReferences(
+	input []schemametadata.IMetadataSchema_IReference,
+) []any {
+	output := []any{}
+	for _, ref := range input {
+		output = append(output, map[string]any{
+			"name": ref.Name,
+			"tags": nestiaSDKMetadataTagMatrix(ref.Tags),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataSets(input []schemametadata.IMetadataSchema_ISet) []any {
+	output := []any{}
+	for _, set := range input {
+		output = append(output, map[string]any{
+			"value": nestiaSDKMetadataSchemaLiteral(set.Value),
+			"tags":  nestiaSDKMetadataTagMatrix(set.Tags),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataMaps(input []schemametadata.IMetadataSchema_IMap) []any {
+	output := []any{}
+	for _, entry := range input {
+		output = append(output, map[string]any{
+			"key":   nestiaSDKMetadataSchemaLiteral(entry.Key),
+			"value": nestiaSDKMetadataSchemaLiteral(entry.Value),
+			"tags":  nestiaSDKMetadataTagMatrix(entry.Tags),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataObjectTypes(
+	input []schemametadata.IMetadataSchema_IObjectType,
+) []any {
+	output := []any{}
+	for _, object := range input {
+		properties := []any{}
+		for _, property := range object.Properties {
+			if property == nil {
+				continue
+			}
+			properties = append(properties, map[string]any{
+				"key":         nestiaSDKMetadataSchemaLiteral(property.Key),
+				"value":       nestiaSDKMetadataSchemaLiteral(property.Value),
+				"description": nestiaSDKOptionalString(property.Description),
+				"jsDocTags":   nestiaSDKJSDocTags(property.JsDocTags),
+				"mutability":  nestiaSDKOptionalString(property.Mutability),
+			})
+		}
+		output = append(output, map[string]any{
+			"name":        object.Name,
+			"properties":  properties,
+			"description": nestiaSDKOptionalString(object.Description),
+			"jsDocTags":   nestiaSDKJSDocTags(object.JsDocTags),
+			"index":       object.Index,
+			"recursive":   object.Recursive,
+			"nullables":   nestiaSDKBoolArray(object.Nullables),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataAliasTypes(
+	input []schemametadata.IMetadataSchema_IAliasType,
+) []any {
+	output := []any{}
+	for _, alias := range input {
+		output = append(output, map[string]any{
+			"name":        alias.Name,
+			"value":       nestiaSDKMetadataSchemaLiteral(alias.Value),
+			"description": nestiaSDKOptionalString(alias.Description),
+			"jsDocTags":   nestiaSDKJSDocTags(alias.JsDocTags),
+			"recursive":   alias.Recursive,
+			"nullables":   nestiaSDKBoolArray(alias.Nullables),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataArrayTypes(
+	input []schemametadata.IMetadataSchema_IArrayType,
+) []any {
+	output := []any{}
+	for _, array := range input {
+		output = append(output, map[string]any{
+			"name":      array.Name,
+			"value":     nestiaSDKMetadataSchemaLiteral(array.Value),
+			"nullables": nestiaSDKBoolArray(array.Nullables),
+			"recursive": array.Recursive,
+			"index":     nestiaSDKOptionalInt(array.Index),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataTupleTypes(
+	input []schemametadata.IMetadataSchema_ITupleType,
+) []any {
+	output := []any{}
+	for _, tuple := range input {
+		elements := []any{}
+		for _, elem := range tuple.Elements {
+			elements = append(elements, nestiaSDKMetadataSchemaLiteral(elem))
+		}
+		output = append(output, map[string]any{
+			"name":      tuple.Name,
+			"elements":  elements,
+			"index":     nestiaSDKOptionalInt(tuple.Index),
+			"recursive": tuple.Recursive,
+			"nullables": nestiaSDKBoolArray(tuple.Nullables),
+		})
+	}
+	return output
+}
+
+func nestiaSDKMetadataTagMatrix(
+	input [][]schemametadata.IMetadataTypeTag,
+) []any {
+	output := []any{}
+	for _, row := range input {
+		items := []any{}
+		for _, tag := range row {
+			items = append(items, nestiaSDKMetadataTypeTag(tag))
+		}
+		output = append(output, items)
+	}
+	return output
+}
+
+func nestiaSDKMetadataTypeTag(tag schemametadata.IMetadataTypeTag) map[string]any {
+	output := map[string]any{
+		"target":    tag.Target,
+		"name":      tag.Name,
+		"kind":      tag.Kind,
+		"exclusive": tag.Exclusive,
+		"value":     tag.Value,
+		"schema":    tag.Schema,
+	}
+	if tag.Validate != "" {
+		output["validate"] = tag.Validate
+	}
+	return output
+}
+
+func nestiaSDKJSDocTags(input []schemametadata.IJsDocTagInfo) []any {
+	output := []any{}
+	for _, tag := range input {
+		text := []any{}
+		for _, item := range tag.Text {
+			text = append(text, map[string]any{
+				"text": item.Text,
+				"kind": item.Kind,
+			})
+		}
+		output = append(output, map[string]any{
+			"name": tag.Name,
+			"text": text,
+		})
+	}
+	return output
+}
+
+func nestiaSDKBoolArray(input []bool) []any {
+	output := []any{}
+	for _, value := range input {
+		output = append(output, value)
+	}
+	return output
+}
+
+func nestiaSDKOptionalString(input *string) any {
+	if input == nil {
+		return nestiaSDKLiteralNull
+	}
+	return *input
+}
+
+func nestiaSDKOptionalInt(input *int) any {
+	if input == nil {
+		return nestiaSDKLiteralNull
+	}
+	return *input
+}